# Franken_Whisper — Technical Due-Diligence Assessment

**The hook:** A 366,000-line Rust ASR stack that beat whisper.cpp 2.99× in a same-invocation duel — and whose bench ledger forbids calling *any* number a "win" unless the incumbent was in the room.

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst — flavors **[Counted]** (I ran the count), **[Git-observed]** (git metadata), **[Code-verified]** (source read). **[CI-observed]** is Tier 2 (seen executing on live CI pages — attests the suite *runs*, not that it is green). **[Maintainer claim]** asserted in README/docs, not independently executed. **[External]** independent sources. **[Inference]** analyst judgment, always labeled. Confidence: **High** / **Medium** / **Low**.

## TL;DR

franken_whisper is an agent-first Rust speech-to-text orchestration stack that wraps whisper.cpp, insanely-fast-whisper, and whisper-diarization behind a unified 10-stage pipeline (Bayesian backend routing, NDJSON robot streaming, SQLite run persistence, TTY audio transport) — and then **replaced the backends it wraps**: a real in-process pure-Rust Whisper engine (ggml parser, log-mel frontend, BPE tokenizer, encoder/decoder transformer on FrankenTorch CPU kernels, greedy decode with whisper.cpp's timestamp rules, cross-attention DTW word timestamps) that ships as the *default* (`Sole` rollout stage, verified in code), plus a Rust-native Sortformer 4-lane speaker diarization port. The headline claims check out against an unusually honest measurement apparatus: a 5,567-line performance ledger with a formal result-class doctrine (self-speedups are *maintenance*, not wins; a campaign win requires the actual incumbent binary running side-by-side in the same invocation with A/A nulls in [0.98, 1.02]) records 2.992045× over whisper.cpp 1.8.3 on large-v3-turbo whole-job and 1.519×/1.512× on tiny.en, all WER-gated against the incumbent. **TRL 5–6. NODUS ring: Explore** — the closest to Pilot in this program (real release artifacts: v0.9.3 installables for 5 platforms, Homebrew tap, ~2.12 GB of SHA-256-trust-root model packages), but no independent benchmark, review, or production deployment found; bus factor 1; no CI config in the tree; CHANGELOG scope window 4 weeks stale at HEAD; and the MIT+OpenAI/Anthropic-rider license withholds all rights — including benchmarking and analysis — from the two leading AI labs. Strongest strength: the evidence machinery — a 26,846-line negative-evidence ledger, the campaign-win doctrine, 5,560 counted test annotations, and a maintainer who records his losses (the failed A/A-null campaign is published as "no admissible verdict," not buried). Strongest ceiling: a single maintainer carrying 366K lines of nightly-only Rust with heavy intra-suite coupling (Frankensqlite, FrankenTorch, FrankenTTS, FrankenTUI, FrankenJAX) and a license that legally bars the frontier labs from even *analyzing* it — the exact audience an agent-era speech stack needs.

## Quick Links

- Repository: https://github.com/Dicklesworthstone/franken_whisper
- README: https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/README.md
- License (MIT + OpenAI/Anthropic rider, read verbatim): https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/LICENSE
- Changelog (scope window ends 2026-08-24 — stale at HEAD): https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/CHANGELOG.md
- Performance ledger (campaign doctrine + all vs-incumbent rows): https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/docs/PERF_LEDGER.md
- Negative-evidence ledger (26,846 lines): https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/docs/NEGATIVE_EVIDENCE.md
- Releases (v0.9.3 latest, 2026-08-15; model artifact releases): https://github.com/Dicklesworthstone/franken_whisper/releases
- v0.9.3 tag: https://github.com/Dicklesworthstone/franken_whisper/releases/tag/v0.9.3
- Native engine contract: https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/docs/native_engine_contract.md
- TTY audio protocol: https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/docs/tty-audio-protocol.md
- Real-time streaming: https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/docs/realtime-streaming.md
- Sortformer Rust port: https://github.com/dicklesworthstone/franken_whisper/blob/HEAD/docs/SORTFORMER_RUST_PORT.md

## Did you know?

`fw doctor` is the only health check I've seen that refuses to call itself ready: a `ready` result means both native model packages (~2.12 GB) passed static preflight against compiled SHA-256 trust roots — but the payload still sets `operationally_verified: false` until an actual transcription succeeds, because (per the README) the project won't certify a pipeline that has never heard a sound [Maintainer claim, Medium; the trust-root pinning and two-package provisioning flow verified in README and `install.sh`].

## Franken-worthy next steps

These are research directions, not engineering tickets: each is novel, specific, falsifiable, and backed by rigor this project has already demonstrated.

1. **Export the campaign-win bench doctrine as a reusable governance template.** The PERF_LEDGER's result classes (self-speedup = *maintenance*, not a win; INCUMBENT-WIN requires the actual incumbent binary in the same invocation, SHA-256 identities for both ELFs, A/A nulls in [0.98, 1.02], and quality gates) plus the AGENTS.md's 12 named reward-hacking patterns are a bench-governance method, not repo scaffolding. **Falsification:** apply the template to a sibling suite (e.g. frankentts) or an external OSS project; if it cannot surface at least one previously-quoted number as non-admissible, or cannot be decoupled from franken_whisper's tooling in one focused workstream, it is local folklore, not a method.

2. **Complete the wasm32 agent-local ASR target.** `fw-wasm/` already ships a real WASM crate (1,011 lines: audio_decode, model, model_distribution) and the sync CPU-only native-engine kernels are OS-free — but the full inference path is not yet a wasm32 build. **Falsification:** compile the native engine + FrankenTorch CPU kernels to wasm32, run the repo's own reference conformance fixture in the sandbox, and publish the transcript (WER vs native) and the real-time factor; WER ≠ 0.0000 on the tiny.en reference or RTF > 1× on a consumer laptop kills the embeddable thesis.

3. **Independent WER certification of the Sortformer Rust port.** The 4-lane fused Sortformer diarizer is the repo's most novel artifact and is explicitly "development-uncertified"; the repo ships its own diarization corpus-manifest machinery, leakage audits, and a DER scorer (`public_corpus.rs`, 31,701 lines). **Falsification:** run the port against a public diarization corpus through that machinery and publish DER vs. the bounded acoustic fallback and vs. upstream Sortformer; if native DER does not beat the acoustic fallback, or the port cannot reproduce upstream behavior within the published tolerance, the native-diarization thesis fails.

4. **Stress the TTY audio transport as a general constrained-channel agent interface.** The mu-law + zlib + base64 NDJSON link with handshake, integrity hashes, deterministic retransmission, and an adaptive bitrate controller is protocol machinery any text-only agent channel could reuse — but the README's own worked example admits the actual mu-law transcode shells out to `ffmpeg`. **Falsification:** drive the full protocol over a simulated adversarial channel (loss, duplication, reordering, bandwidth clamps) with an ffmpeg-free Rust codec and verify the deterministic-replay invariants in `docs/tty-replay-guarantees.md`; any invariant violation or ffmpeg-dependence that cannot be eliminated kills the "pure-Rust transport" claim.

5. **Export the Brier-calibrated Bayesian router to a second domain.** The backend router (Beta posteriors per backend, explicit loss matrix, Brier-scored calibration sliding window, deterministic fallback when mis-calibrated, 200-entry evidence ledger, full decision-contract event) is the most formal adaptive-controller pattern in the program, governed by the alien-artifact engineering contract. **Falsification:** instantiate the same router for a different selection problem (e.g. TTS backend selection in frankentts, or ffmpeg-vs-symphonia decode path selection); if it cannot beat a static heuristic with statistical significance — or if the calibration machinery cannot be decoupled from ASR specifics — the router is a one-off, not a method.

---
## 4.1 Header

| Field | Value |
|---|---|
| Repository | https://github.com/Dicklesworthstone/franken_whisper |
| Pinned revision | `408b7e790a7bda4cc6e47bd4b66db8bec0418658` — 2026-09-22 00:31:24 −0400 (= 04:31 UTC) [Verified, High] |
| Assessment date | 2026-09-22 |
| Language / toolchain | Rust, edition 2024, pinned **nightly-2026-08-31** (`rust-toolchain.toml`) [Verified, High] |
| License | MIT License **with OpenAI/Anthropic Rider** — NOT OSI open source; text read verbatim, rider scope quoted in §4.8 [Verified, High] |
| Scale | Single binary crate `franken_whisper` v0.9.3 + 3 bin targets; **365,978 Rust lines / 256 files** (src 297,256 / 68 files; tests 26,748 / 39 files; benches 13,210; examples 24,682; fw-wasm 1,011; fw-ios 1,804) [Verified, High] |
| Stars / forks | 93 / 10 (GitHub API, 2026-09-22) [External, High] |
| Releases / tags | v0.9.3 (2026-08-15), v0.9.2, v0.8.0, v0.7.2, v0.7.1, v0.5.0, v0.2.0 — plus model artifact releases (`whisper-large-v3-turbo-f16-v1`, `sortformer-v2.1-f32-v1`, `whisper-tiny-f16-v1`, `whisper-tiny-en-f16-v1`) [External API, High] |
| Last push | HEAD 2026-09-22; **latest release 2026-08-15 — 5 weeks of main-branch work unreleased** [Verified/External, High] |
| Maintainer | Single human contributor: Dicklesworthstone (3,778 commits per API; Jeffrey Emanuel per LICENSE) — bus factor 1 [Verified, High] |
| Inception | v0.2.0 release notes 2026-06 (~108 days before assessment); CHANGELOG "inception" not separately dated [External/Maintainer, Medium] |

**Analyst method.** Fresh shallow clone of HEAD to `~/workspace/.scratch/franken_whisper-verify/` (HEAD `408b7e7`, 2026-09-22). Read: README.md (5,517 lines, fully), LICENSE (verbatim), CHANGELOG.md (head + structure), AGENTS.md (fully), `docs/PERF_LEDGER.md` (doctrine + all CAMPAIGN WIN rows 2026-07-27–31 incl. the full 2026-07-30 tiny.en row), `docs/NEGATIVE_EVIDENCE.md` (head), `docs/SORTFORMER_RUST_PORT.md` (existence), Cargo.toml (deps, bins, features), rust-toolchain.toml. Grep-verified: Rust line/file counts by directory, `#[test]` annotation count (5,560), `unsafe` code-line census in src (33 hits; all in annotated `#[allow(unsafe_code)]` blocks with local SAFETY comments), `ROBOT_SCHEMA_VERSION = "1.1.0"`, `FW-*` code inventory (35 unique codes vs 13 claimed terminal), **tokio absence (zero hits in Cargo.toml and src/)**, asupersync usage in production paths (`orchestrator.rs`, `storage.rs`, `model_distribution.rs`, `lib.rs`), symphonia use in `src/audio.rs` and cpal use in `src/capture.rs`, sibling path deps (frankensqlite/frankentorch/frankentts/frankentui/frankenjax), the `NativeEngineRolloutStage::Sole` default (`backend/mod.rs:2027`) and `gate_recommended_order_for_rollout` stage-gating, all 10 `PipelineStage` variants in `src/orchestrator.rs`, `ReplayEnvelope` hash fields (`input_content_hash`, `output_payload_hash`, `backend_identity`, `pcm_sha256`), native_engine module listing, fw-wasm crate contents, tests/ directory listing (39 suites), and CAMPAIGN WIN row recency (none post-dates 2026-07-31). Fetched and confirmed resolution of every Quick Link. Web-searched for independent coverage (benchmarks, reviews, production use). **Not done:** did not compile, run tests, execute the binary, reproduce any benchmark, run the conformance harness, or attempt a release-binary install — all behavioral and performance claims rest on maintainer evidence plus revision-bound documentation. No `.github/` directory exists in the tree — CI configuration could not be inspected (reported as a finding, not an assumption). Contributor count from API (3,778 commits); commit history beyond HEAD not cloned.

## 4.2 Executive verdict

franken_whisper is a **substantive, released, agent-first Rust speech stack that outgrew its original orchestration brief**: it began as a unified wrapper around whisper.cpp / insanely-fast-whisper / whisper-diarization (adaptive Bayesian routing, sequenced NDJSON robot events, SQLite run history, cooperative cancellation) and then replaced the thing it orchestrates — a genuine in-process pure-Rust Whisper engine (ggml parser, log-mel frontend, BPE tokenizer, FrankenTorch CPU kernels with Metal on macOS, greedy decode with whisper.cpp's full timestamp-rule suite, cross-attention DTW word timestamps) that ships as the **default** (`NativeEngineRolloutStage::Sole`, verified in `backend/mod.rs`), plus a Rust-native 4-lane Sortformer speaker-diarization port. The performance claims are governed by the most explicit honesty apparatus observed in this program [Inference, Medium]: the PERF_LEDGER's result-class doctrine makes self-speedups *maintenance* rather than wins, and the flagship rows are true campaign measurements — the actual `whisper-cli` incumbent binary (SHA-256-pinned) ran side-by-side in the same invocation, with seven-round A/A nulls inside [0.98, 1.02], full host provenance (Threadripper PRO 5995WX, all CPUs `performance` governor, quiescence gates), and WER-gated transcript equivalence (2.992045× whole-job on large-v3-turbo at WER 0.025090, 7/279 edits; 1.518913× / 1.512159× on tiny.en at WER 0.0000). **But:** independent validation is zero — no third-party benchmark, review, or deployment found; the 2.99× flagship leans on an algorithmic lever (ToMe token merging) the incumbent structurally cannot express, and its quality gate is looser (7 edits) than the 2.27× control row (3 edits); the GitHub repo description still advertises "zero unsafe code" [External snippet, Medium] while HEAD's `src/` carries 33 annotated `unsafe` code lines (the "zero unsafe" era ended when the explicit audited-kernel policy landed); the native build needs a nightly toolchain plus sibling FrankenSuite checkouts (FrankenTorch kernels are load-bearing — AGENTS.md notes a Linux build *fails* without them); CHANGELOG's scope window ends 2026-08-24 while HEAD is 2026-09-22; the tree contains **no CI configuration at all**; and the MIT+OpenAI/Anthropic-rider license withholds even benchmarking and analysis rights from the two labs most likely to evaluate agent speech infrastructure. **NODUS: Explore** (the Pilot case is real — release artifacts exist — but the five-week release gap, zero independent validation, and missing in-tree CI push the call down, per the ring-down rule). **Wardley:** custom-built ASR core at early product, native diarization at genesis. Its most durable contribution may be the **measurement governance** (campaign-win doctrine, negative-evidence ledger, 12 named reward-hacking patterns), not the engine [Inference, Medium].

## 4.3 Claim inventory: demonstrated vs aspirational

Status values: *demonstrated* / *partially demonstrated* / *aspirational* / *disproven* / *stale*.

| # | Claim | Status | Evidence |
|---|---|---|---|
| 1 | In-process pure-Rust Whisper engine (ggml parse, log-mel, BPE, transformer, greedy decode, DTW word timestamps), no FFI/Python/subprocess | **Partially demonstrated** | [Verified, High] `src/native_engine/` (11 modules: ggml, mel, tokenizer, encoder, decoder, decode, dtw, nn, weights, plat); FrankenTorch path deps in Cargo.toml; behavior not executed by analyst |
| 2 | Native engine is the shipped default (`Sole` rollout stage) | **Demonstrated** | [Verified, High] `native_rollout_stage()` returns `NativeEngineRolloutStage::Sole` by default with env-var override (`src/backend/mod.rs:2027`) |
| 3 | 2.99× faster than whisper.cpp (large-v3-turbo, 124.5 s whole job, matched greedy) | **Partially demonstrated** (method strong; attribution caveated) | [Maintainer claim with strong method, Medium] — ledger row 2026-07-31: 2.992045×, CI95 [2.937, 3.026], n=7, same-invocation, A/A nulls in [0.98,1.02], WER 0.025090 (7/279 edits); **caveat:** flagship arm uses ToMe token-merge (R=500) the incumbent cannot express; un-merged control row measured 2.273710× |
| 4 | 1.52×/1.51× faster than whisper.cpp (tiny.en, 124.5 s / 300 s) | **Partially demonstrated** | [Maintainer claim with strong method, Medium] — ledger row 2026-07-30: 1.518913× (CI95 [1.481, 1.534], WER 0.027237) / 1.512159× (CI95 [1.469, 1.527], WER 0.011236), n=3 each, same-invocation, A/A nulls in [0.98, 1.02] (one null CI not straddling 1.0 — admissible under the ledger's stated rule, calibrating the 2× floor); the README's "WER 0.0000" is a *separate* reference-fixture conformance claim, not these rows' figure |
| 5 | "zero unsafe code" (GitHub repo description) | **Stale/disproven at HEAD** | [External snippet + Verified code, Medium-High] — the repo's public description (per search-index snippet) still reads "107K lines, 2000+ tests, zero unsafe code"; HEAD's `src/` carries 33 `unsafe` code lines, all in `#[allow(unsafe_code)]` blocks with local SAFETY arguments (e.g. `nn.rs` GEMM uninit buffers, AVX2 kernels); README's own policy section now says `#![deny(unsafe_code)]` with audited scoped exceptions — the description is a stale artifact of the pre-kernel era |
| 6 | Rust-native Sortformer diarization by default (4 lanes, overlapping turns) | **Partially demonstrated** | [Verified existence, High] — `docs/SORTFORMER_RUST_PORT.md` (1,263 lines), `src/diarization.rs` (41,135 lines), model artifact release `sortformer-v2.1-f32-v1`; **explicitly "development-uncertified"** per README; 4-lane capacity is a hard boundary |
| 7 | Adaptive Bayesian backend routing (Beta posteriors, Brier calibration, loss matrix, deterministic fallback) | **Partially demonstrated** | [Verified machinery, High] — routing evidence ledger, calibration window, decision-contract events described in README worked example; behavioral calibration not executed by analyst |
| 8 | Real-time NDJSON streaming (`fw robot listen`, schema v1.1.0, sequenced stage events) | **Partially demonstrated** | [Verified, High] — `ROBOT_SCHEMA_VERSION = "1.1.0"` in `src/robot.rs`; listen driver + AlignAtt emission policy in CHANGELOG Unreleased; end-to-end latency certification still open (`bd-rt-e2e-0zo5`) per CHANGELOG |
| 9 | SQLite run history with JSONL export/import, replay envelopes, crash-safe transactions | **Partially demonstrated** | [Verified, High] — `src/storage.rs` (11,246 lines), `src/sync.rs` (16,178 lines), savepoint rollback, asupersync-backed static runtime; live crash recovery not executed by analyst |
| 10 | TTY audio transport (mu-law + zlib + base64 NDJSON, handshake, retransmit, adaptive bitrate) | **Partially demonstrated** | [Verified, High] — `docs/tty-audio-protocol.md` (548 lines), `docs/tty-replay-guarantees.md`; **nuance:** README's own worked example states the actual mu-law transcode "shells out to `ffmpeg`" — the framing is Rust, the codec head is not |
| 11 | 10-stage composable pipeline (Ingest → Persist), per-stage budgets, PipelineBuilder ordering validation | **Demonstrated** (structure; runtime behavior not executed) | [Verified, High] — all 10 `PipelineStage` variants enumerated in `src/orchestrator.rs` (Ingest, Normalize, Vad, Separate, Backend, Accelerate, Align, Punctuate, Diarize, Persist); `gate_recommended_order_for_rollout` gates engine order by rollout stage |
| 12 | 13 exact terminal `FW-*` error codes | **Partially demonstrated** | [Verified, High] — 35 unique `FW-*` codes counted in `src/` (includes DTW-projection invariant family); the "13 terminal" subset classification not independently verified |
| 13 | In-process audio decode (MP3/AAC/FLAC/WAV/OGG/ALAC via symphonia; ffmpeg fallback only) | **Partially demonstrated** | [Verified dep + use, High] — symphonia used in `src/audio.rs`, cpal mic capture in `src/capture.rs`; NEGATIVE_EVIDENCE records a measured 1.4–1.7× win of builtin normalize over the ffmpeg subprocess on a 600 s MP3; live decode not executed |
| 14 | Cooperative cancellation via asupersync (cancel-correct orchestration) | **Partially demonstrated** | [Verified, High] — asupersync =0.5.0 from crates.io, used in production paths: `orchestrator.rs` runtime builder, `storage.rs` static runtime, `model_distribution.rs` HTTP client, `lib.rs` Cx propagation |
| 15 | 2000+ tests | **Demonstrated** (as counted) | [Verified, High] — 5,560 `#[test]` annotations counted across src/tests/benches; execution/greenness not verified by analyst |
| 16 | 107K lines (repo description) | **Stale** | [Verified, High] — HEAD counts 365,978 Rust lines (256 files); the description figure predates the current tree by a large margin |
| 17 | Release installables (5 platforms), Homebrew tap, 2.12 GB pinned model packages with SHA-256 trust roots | **Partially demonstrated** | [Verified, High] — releases v0.5.0–v0.9.3 + model artifacts on GitHub API; `install.sh` SHA-256 flow and compiled trust roots per README; install not executed; **latest release 5 weeks behind HEAD** |
| 18 | iOS C ABI + SwiftUI (`fw-ios`), WASM surface (`fw-wasm`) | **Partially demonstrated** | [Verified, High] — `fw-ios/` (3 files, 1,804 lines), `fw-wasm/` (4 files, 1,011 lines: audio_decode, model, model_distribution), `docs/fw_ios_contract.md`; full native-engine wasm32 target not present |
| 19 | Native backends once emitted deterministic placeholder output (v0.2.0-era failure mode) — now guarded | **Demonstrated** (the guard; the history is a maintainer admission) | [Verified, High] — `tests/no_canned_phrases.rs` exists as a regression guard; the v0.2.0 release notes admit the three in-process "pilot" engines previously emitted deterministic placeholders before the genuine engine landed |

## 4.4 Architecture (reconstructed, not summarized)

[Verified from the clone; README diagrams treated as claims where noted]

**Crate topology:** a **single binary crate** `franken_whisper` v0.9.3 (edition 2024, nightly-only: `#![feature(portable_simd)]` at the crate root) with three bin targets — `franken_whisper`, `fw` (the agent-facing alias, same entry point), and `sortformer-f16-downcast` (a model-conversion utility). This is a monolith, not a workspace: `src/` is 68 files / 297,256 lines, with the mass concentrated in four large modules — `diarization.rs` (41,135), `public_corpus.rs` (31,701, corpus-manifest/leakage-audit/scoring machinery), `orchestrator.rs` (17,889, the 10-stage pipeline + backend dispatch), `sync.rs` (16,178, JSONL export/import + replay packs) — plus `storage.rs` (11,246, SQLite via FrankenSQLite), `backend/mod.rs` (10,355, bridges + native dispatch + rollout governance), `model.rs` (9,016). `tests/` holds 39 suites (26,748 lines): conformance harness/comparator/oracle, robot contract tests, metamorphic suites (audio, accelerate, speculation), speculation/e2e, ledger integrity, installer contract, iOS header parity, `no_canned_phrases` (guards against placeholder-output regressions — a scar from the v0.2.0 era when native backends emitted deterministic placeholders). `benches/` 30 files, `examples/` 111 files (mostly SIMD/perf probes — the visible exhaust of the PERF_LEDGER campaign).

**Native engine** (`src/native_engine/`, 11 modules): `ggml.rs` (model parser, f32/f16 `hparams.ftype` 0/1; quantized variants rejected), `mel.rs` (log-mel frontend), `tokenizer.rs` (byte-level BPE), `encoder.rs` (transformer encoder incl. the ToMe token-merge lever, `TOME_R_LARGE_DEFAULT`), `decoder.rs`/`decode.rs` (greedy decode with whisper.cpp's logit-filter/timestamp rules), `dtw.rs` (cross-attention DTW word timestamps with per-model alignment-head presets), `nn.rs` (kernel glue; AVX2 `#[allow(unsafe_code)]` kernels with SAFETY comments; `fully-overwritten-buffer` uninit pattern), `weights.rs`, `plat.rs`. Matmuls delegate to **FrankenTorch** (`ft-kernel-cpu`, `ft-core`, path deps; `ft-kernel-metal` target-gated on macOS — AGENTS.md: "a Linux build FAILS if that checkout is absent"). Source builds stage exact sibling commits via `scripts/prepare_release_siblings.sh`; published packages resolve the siblings from crates.io.

**Data flow (native path):** audio → symphonia decode (`src/audio.rs`; ffmpeg fallback) → normalize → VAD → `native_engine` (mel → encoder [ToMe merge] → greedy decoder) → DTW word alignment → diarization projection (Sortformer 4-lane timeline projected onto Whisper segments) → punctuate → SQLite persist (`storage.rs`, asupersync static runtime, savepoint rollback) → NDJSON robot events (schema v1.1.0). Bridge path: same pipeline with backend stages shelling out to `whisper-cli` / `insanely-fast-whisper` / `python3`+pyannote, selected by the Bayesian router. **No tokio anywhere** — zero hits in Cargo.toml and `src/` [Verified, High]; cancellation and concurrency run on **asupersync** (the =0.5.0 crates.io release), used for the runtime builder, HTTP model distribution, and structured-concurrency scopes. (For context: in the sibling FrankenRedis assessment, asupersync was evaluated and explicitly rejected — here it is load-bearing production infrastructure.)

**Memory-safety posture** [Verified, High]: crate root is `#![deny(unsafe_code)]` (deliberately *not* `forbid`, so the native-engine kernels can opt in). 33 unsafe-leading code lines in `src/`, all inside `#[allow(unsafe_code)]` blocks carrying local SAFETY arguments — spot-verified in `nn.rs` (fully-initialized GEMM output buffers; AVX2 in-bounds lane guards with scalar tails). The README's "Audited Unsafe Boundaries" section discloses the policy and points at the negative-evidence ledger for the performance rationale. The GitHub repo description's "zero unsafe code" is therefore a stale artifact, but the current posture is disclosed, not hidden.

**Dependency posture:** production deps include asupersync, symphonia, rusqlite-via-fsqlite (Frankensqlite path dep), serde, cpal (mic capture), reqwest-equivalent via asupersync-http; the `tui` feature pulls frankentui (optional), `fj-oracle` pulls frankenjax (test-only differential oracle). The intra-suite coupling is the structural risk: a source build requires five sibling checkouts at pinned commits, and the native engine is hard-coupled to FrankenTorch's kernel crates.

**README-vs-code drift (governance signal):** the GitHub repo description (per search-index snippet [External, Medium]) says "107K lines, 2000+ tests, zero unsafe code" — HEAD has 366K lines and 33 annotated unsafe sites in src (test count is the one figure that still holds, and then some). CHANGELOG scope window ends 2026-08-24, HEAD is 2026-09-22. The "zero unsafe" language also survived into older README copies (visible in fork descriptions). None of this is concealed in the docs that matter — the README's unsafe section is current — but the storefront copy lags the tree.

---
## 4.5 Benchmark and conformance audit

### Maintainer-produced numbers (all from `docs/PERF_LEDGER.md` — the doctrine matters as much as the numbers)

The ledger's **result-class doctrine** (effective 2026-07-27) is the audit's load-bearing artifact: a franken-before/franken-after comparison is **Result class: SELF-SPEEDUP / MAINTENANCE** and "may justify landing code, but it does not count as a campaign win"; **INCUMBENT-WIN / CAMPAIGN WIN** requires the actual legacy incumbent running side-by-side in the same invocation, with the incumbent binary's SHA-256 recorded, same-invocation dual A/A controls, and a 2x-null-margin statistical gate. AGENTS.md additionally names 12 forbidden reward-hacking patterns (gate self-weakening, golden regeneration, tautological tests, bench-path hardcoding, …). Competitive host provenance (2026-07-29) requires full CPU/governor/affinity/quiescence records, and uniform `performance` governor for any absolute claim. Only CAMPAIGN WIN rows may support public competitive claims.

| Workload | franken ÷ incumbent | Method controls | Would it survive independent rerun? |
|---|---|---|---|
| large-v3-turbo, 124.5 s / 5 windows, whole job, no timestamps | **2.992045×** (CI95 [2.937305, 3.025916], n=7) | Same-invocation vs whisper.cpp 1.8.3 `whisper-cli` (ELF SHA-256 recorded); 7 rounds, alternating arm order; dual A/A nulls 1.001413 / 0.999952 (in [0.98, 1.02]); all gates clear (quality/thread/normalization/host-wide/identity/load); Threadripper PRO 5995WX, all 128 CPUs `performance`, quiescence max_busy 0.0 | The method is the strongest in this program — but the flagship arm runs **ToMe token merging (R=500)**, an algorithmic lever whisper.cpp structurally cannot express; the identical-binary un-merged control arm measured **2.273710×** in the same session. The honest citation is "2.99× with ToMe, 2.27× without" |
| tiny.en, 124.5 s / 5 windows, transcribe only | **1.518913×** (CI95 [1.480841, 1.534221]) | Same as above, n=3; A/A nulls 0.999239 / 1.005308 (in [0.98, 1.02]; the whisper.cpp null CI does not straddle 1.0 — admissible under the ledger's stated rule, calibrating the 2× floor); WER 0.027237 on this workload | Strong method; transcript near-identical on this cell |
| tiny.en, 300 s / 10 windows, transcribe only | **1.512159×** (CI95 [1.468530, 1.526903]) | Same as above; WER 0.011236 | Strong method |
| tiny.en, segment-timestamp workload | **1.415379×** (CI95 [1.185640, 1.866960]) | Same-invocation, alternating arm order; notably wider CI than the text-only cells | Weaker precision; included so the table is not cherry-picked |
| tiny.en re-certification (clean-start, n=31, independent load split) | **1.479272×** | 2026-07-28; independently split by a host-load covariate | Replication of the tiny.en win under a stricter protocol |
| large-v3-turbo whole job (un-merged control, same session) | **2.273710×** (CI95 [2.208881, 2.303804]) | Identical binary, `FW_TOME_R=0`, same quiet host minutes later | This is the number that survives an "engineering only, same algorithm" framing — and the ledger published it in the *same row* as the flagship |

**Quality gating (the part most benches skip):** the 2.99× row carries WER 0.025090 (7/279 edits vs the incumbent) with `quality_clear=true` against `wer_max=0.100000`; the ledger's R-value sweep notes R>550 "turns chaotic" and R=650's good score was "a noise trough between two failures" — i.e. the lever was chosen off a measured curve with the failure modes published. The README headline ("2.99×… The whole-job turbo row matches 279/279 words at WER 0.010753") mixes the flagship ratio with the *control arm's* WER (3 edits) — a small but real headline-vs-ledger inconsistency: the 2.99× arm's own WER is 0.025090, not 0.010753 [Verified from ledger vs README, High]. Both are under the gate, but the packet records the discrepancy.

**Published non-wins:** the 2026-08-11 Metal fused-encoder entry is labeled **NO ADMISSIBLE PERFORMANCE VERDICT** ("benchmark executable's SHA-256 was not recorded… measurements remain diagnostic only"); the 2026-08-23 first `robot listen` latency campaign records A/A nulls of 0.963 / 0.936 against the required [0.98, 1.02] band on a loaded shared Mac and therefore "banks NO cross-arm comparison" — the numbers (TTFT, commit lag, WER per fixture) are published, the comparison is refused. The reward-hacking doctrine is not decorative — it fires in public.

**Recency caveat:** the newest CAMPAIGN WIN rows in the 5,567-line ledger are the two 2026-07-31 flagship rows — **no campaign measurement post-dates 2026-07-31**, ~7.5 weeks before HEAD. The ledger's own row carries the scope limitation verbatim: *"Do not generalize these text-only tiny.en results to timestamps or large-v3-turbo."* The headline numbers are therefore certified but aging; a HEAD-current re-certification is an open item.

**Reproduction cost (honest):** the tree is ~366K Rust lines plus sibling checkouts (frankentorch/frankensqlite/frankentts at pinned commits) on a **pinned nightly** (`#![feature(portable_simd)]`); the sanctioned path is a remote-worker setup (`rch exec` on maintainer workers) with pinned-core hardware; the audio fixture and model SHA-256s are recorded but the fixtures themselves are not all in the repo. Expect hours and exact hardware, not minutes.

### Conformance evidence

- **Cross-engine conformance harness:** `tests/conformance_harness.rs` + comparator + oracle suites; 44 fixture files in `tests/fixtures/conformance/`; **50 ms canonical timestamp tolerance** (`CANONICAL_TIMESTAMP_TOLERANCE_SEC`, "single source of truth across the entire codebase" per README); spec-clause→test traceability in `tests/COVERAGE.md`; native rollout gates (Shadow→Validated→Fallback→Primary→**Sole**) with conformance gates between stages [Verified fixtures + constant exist, High; behavioral results Maintainer claim, Medium].
- **Differential oracle:** `fj-oracle` feature wires FrankenJAX as a seeded differential oracle for native-kernel conformance (1e-4 tolerance, `docs/conformance-contract.md`) — test-only, explicitly "not a production acceleration backend" [Maintainer claim, Medium].
- **Metamorphic suites:** audio (decoder-path permutation stability), accelerate (softmax permutation-equivariance, layer-norm invariants), speculation (string-distance metric properties) — property tests where the oracle is a mathematical invariant, not a golden file [Verified suites exist, High].
- **`no_canned_phrases`:** a regression guard against the v0.2.0-era failure mode (native backends emitting deterministic placeholder output) — the scar tissue is in the test suite [Verified, High].
- **CI:** none found — the tree has no `.github/` directory, and no other CI config was located. Conformance claims therefore rest entirely on maintainer-executed runs. This is the single largest evidence gap in the packet [Verified absence, High].

### Independent numbers

**None found.** Web search returns only the repository, its own docs/commit pages, two forks (joyshmitz, ljubomirj — mirrors, not reviews), and the v0.2.0 release notes. No third-party benchmark, code review, production deployment, or user report found [External, High within recall caveats]. **Independent validation: zero.**

## 4.6 Comparison: who owns the lane

**The incumbents** are the three backends franken_whisper wraps: **whisper.cpp** ([ggml-org/whisper.cpp](https://github.com/ggml-org/whisper.cpp), URL verified 200 on 2026-09-22; the ledger pins incumbent version 1.8.3 by binary SHA-256), which owns fast local CPU inference; **faster-whisper / insanely-fast-whisper** (own GPU batching ergonomics); and the **whisper-diarization** lineage (Whisper + NeMo/Sortformer diarization). Around them: **WhisperX** (faster-whisper + wav2vec2 + pyannote), **whisper-timestamped** (DTW word timestamps), **WhisperLive** (streaming), **WhisperS2T**, and the **commercial APIs** (Groq, Deepgram, AssemblyAI) that own the no-ops lane. **Why the incumbents win today, in one paragraph:** trust and surface area — whisper.cpp has years of production hardening, a model zoo, bindings in every language, and an operator community; the APIs have SLAs; franken_whisper has a stronger bench apparatus than any of them [Inference, Medium] but zero independent validation, a nightly-only toolchain, 366K lines under one maintainer, and a license that bars the two AI labs most likely to stress-test it. Nobody migrates a production transcription pipeline to a 0.9.3 single-maintainer binary on maintainer-measured numbers, however well-governed.

**The genuinely unoccupied lane [Inference, Medium]:** the *agent-first local speech stack* — structured streaming (NDJSON, stable schema, exact error codes), Bayesian backend selection with a published decision contract, durable run history with replay envelopes, and an in-process engine fast enough to make the whole thing one binary. whisper.cpp is a library with a CLI; the commercial APIs are black boxes where audio necessarily leaves the machine for inference [Inference, High — definitional for cloud APIs]; nobody else builds the orchestration-and-evidence layer for agents. franken_whisper's native engine is what makes the lane credible — without it, this would be a smart router; with it, it is a self-contained agent speech organ. The Sortformer port (in-process, 4-lane, no Python, no HF token) is the same wedge for diarization. Both wedges are real but "development-uncertified," and the lane stays unoccupied only until an incumbent adds structured output — which is a product decision, not a research problem.

## 4.7 Technical merit and adversarial review

**Strengths:**
1. **Measurement governance without peer in this program.** The result-class doctrine (self-speedup = maintenance; campaign win = incumbent in the same invocation), the 12 named reward-hacking patterns in AGENTS.md, the 26,846-line negative-evidence ledger, and the *published* non-verdicts (Metal kernel SHA-256 missing → "no admissible verdict"; failed A/A nulls → "therefore no comparative claims") constitute a transferable method for honest benchmarking [Verified, High].
2. **The native engine is real and the wins are attributed, not just measured.** The flagship ledger row ships the un-merged control arm (2.27×) next to the ToMe flagship (2.99×), reproducing the prior certified row to within 0.4% across sessions — so the +31.6% is the merge, not drift. Publishing the control arm next to the win is among the most honest benchmarking acts observed in this program [Inference, Medium — the analyst has not independently re-verified every sibling packet's ledger].
3. **Genuine asupersync integration.** Unlike the sibling repo that evaluated and rejected it, franken_whisper runs its orchestration, storage, and model-distribution HTTP on asupersync (=0.5.0, crates.io) — structured concurrency with cancellation tokens as the operational backbone, not a fashion dependency [Verified, High].
4. **The rollout governance is a real deployment discipline.** Five stages (Shadow → Validated → Fallback → Primary → Sole) with conformance gates, env-var overrides, kill switches (`FRANKEN_WHISPER_NATIVE_TAIL_TRUNCATE=0`), and a `DISCREPANCIES.md` for known native-vs-bridge divergences — this is how you ship a from-scratch engine without lying about parity [Verified, High].
5. **Release engineering is serious.** SHA-256-verified installables for 5 platforms, Homebrew tap, ~2.12 GB of model packages admitted only after compiled SHA-256 trust roots pass, `doctor` that refuses `operationally_verified` until a real transcription succeeds, airgap-capable installer [Maintainer claim + Verified release artifacts, Medium-High].

**Weaknesses:**
1. **Bus factor 1 at 366K lines of nightly-only Rust.** One human (3,778 commits per API) plus agent personas; the tree needs `#![feature(portable_simd)]`, pinned nightly, and five sibling checkouts at exact commits. Review depth cannot cover this surface; the AGENTS.md's own warning about concurrent agents ("a dozen other agents… multiple times per minute") reads as the maintainer's acknowledgment of the coordination problem [Verified + Inference, High].
2. **Zero independent validation of any kind.** No third-party benchmark, review, deployment, or user report found. The entire evidence edifice is maintainer-built and maintainer-executed — the doctrine is admirable, but doctrine is not independence [External, High within recall].
3. **No CI in the tree.** There is no `.github/` directory and no other CI config in the clone. A project whose central claim is conformance-gated rollout has no visible continuous gate — the conformance harness exists as code, but whether it runs on every commit is unverifiable [Verified absence, High].
4. **The flagship number leans on an unmatchable lever.** The 2.99× arm uses ToMe token merging that whisper.cpp structurally cannot express — the comparison is "different algorithms," and the README headline pairs the flagship ratio with the control arm's better WER (0.010753 vs the flagship's 0.025090). Both facts are in the ledger, but the headline elides them [Verified, High].
5. **Heavy, coupled, and partially undisclosed-at-install weight.** ~2.12 GB of model downloads gated behind a 2.4 GB free-space check; the native build fails on Linux without the FrankenTorch checkout; the mu-law TTY head shells out to ffmpeg despite the "no external decoder" framing; quantized ggml models are rejected; Sortformer is "development-uncertified" with a hard 4-speaker capacity [Verified, High].
6. **Docs and storefront lag the tree.** CHANGELOG scope window ends 2026-08-24 (4 weeks before HEAD); the GitHub description's "107K lines / zero unsafe code" is stale on both counts [External snippet, Medium]; the latest release (v0.9.3, 2026-08-15) is 5 weeks behind HEAD; **no CAMPAIGN WIN row post-dates 2026-07-31** — the flagship numbers are ~7.5 weeks old at HEAD, so the headline claims are aging, not live. Each instance is minor; the pattern is the governance signal the Rulebook asks for [Verified, High].
7. **Sibling-coupling failure mode.** The native engine hard-depends on FrankenTorch's kernel crates at exact sibling commits (AGENTS.md: a Linux build *fails* without the checkout). A breaking change in frankentorch, a stale pin, or a lost checkout kills the native engine — and with it the `Sole` default the whole product story rests on — with no graceful degradation [Verified, High].
8. **Supply-chain asymmetry in the install story.** The release *binaries* are SHA-256-verified and the model packages are admitted only after compiled trust roots pass — but the installer itself is fetched via `curl -fsSL … | bash` with no pinning: the most-verified artifact in the chain is bootstrapped by the least-verified step [Verified from README install block, High].

**Steelman of the bear case:** franken_whisper is a monumentally over-instrumented answer to a solved problem. whisper.cpp already transcribes fast on CPU, the commercial APIs already transcribe without ops, and the "agent-first" differentiators — NDJSON streaming, Bayesian routing, SQLite history — are conveniences, not capabilities: any agent framework can wrap whisper.cpp with ten lines of Python and get 90% of the value. The native engine's headline win depends on token merging, an algorithmic trick the incumbent could adopt in an afternoon; the Sortformer port is uncertified and capped at four speakers; and the entire 366K-line edifice — nightly-only, five sibling checkouts, one maintainer — is one toolchain breakage or one maintainer burnout away from bit-rot. The bench doctrine is the best in the program, but it governs numbers nobody independent has reproduced, under a license that forbids the two labs best equipped to reproduce them from even trying. Methodologies don't get paged at 3 AM, and neither do 0.9.3 binaries with no users.

**Hook audit (the packet grades its own hook):** "A 366,000-line Rust ASR stack that beat whisper.cpp 2.99× in a same-invocation duel — and whose bench ledger forbids calling *any* number a 'win' unless the incumbent was in the room." Line count verified (365,978, reported unrounded); the 2.99× is the ledger's certified campaign row (2.992045×) with the incumbent SHA-256-pinned in the same invocation; the "forbids" clause is the ledger's literal result-class doctrine (SELF-SPEEDUP/MAINTENANCE vs INCUMBENT-WIN, effective 2026-07-27). "Duel" is stylistic but accurate to the alternating-arm design. The hook survives — with the packet's own §4.5 caveat (ToMe lever, WER pairing) attached.

## 4.8 License and governance (material, not boilerplate)

**License text, read verbatim** [Verified, High]: `LICENSE` is the MIT License **with an "ADDITIONAL RIDER / RESTRICTION (OpenAI / Anthropic)"** that is "part of the 'conditions' of this License" and "controls" in any conflict. Quoted scope: *"Restricted Parties" means OpenAI, L.L.C.; Anthropic, PBC; any of their respective Affiliates; and any person or entity acting directly or indirectly on behalf of, for the benefit of, or under the direction of any of the foregoing (including any officer, director, employee, contractor, agent, consultant, service provider, or representative).* *"Notwithstanding any other provision of this License, no rights are granted to any Restricted Party."* Disclosure/hosting/distribution to them is forbidden. *"use" includes, without limitation: copying, modifying, … benchmarking, testing, analyzing, indexing, or incorporating the Software or any Derivative Works into any dataset, training corpus, evaluation harness, or pipeline for machine learning or other automated systems.* Breach terminates all permissions automatically; injunctive relief and attorneys' fees reserved to Jeffrey Emanuel (copyright holder, 2026). **Classification: NOT OSI open source** — named-party discrimination with a use restriction covering even benchmarking and analysis. Source-available with a targeted exclusion.

**The rider as strategy:** defensively coherent (it prevents the two labs best positioned to absorb the work from doing so without permission) and offensively self-sabotaging: this is an *agent* speech stack, and the excluded parties *are* the agent-infrastructure builders. Worse, the rider's breadth (benchmarking, testing, and *analyzing* are forbidden uses) chills exactly the independent validation the project most needs — no third party downstream of a restricted party can publish a benchmark without lawyering the rider first, which is a live hypothesis for why independent validation is zero [Inference, Medium]. The README discloses the rider ("MIT + rider", badge links to LICENSE) — better disclosure than some siblings — but the commercial-API comparison table's cell reads, verbatim, `**yes (MIT + rider)**`, which undersells the restriction's practical effect: a procurement reader sees "yes" first. Adoption ceiling: hard for labs, lab-adjacent enterprises, and any benchmark publisher touching restricted parties.

**Governance:** owner-directed single maintainer; no visible external contributors (API: sole committer, 3,778 commits); the `.beads/` issue tracker is in-tree (visible in the clone); commit velocity is extreme (agent personas named in AGENTS.md/ledger bylines: BlackThrush, CoralCoast). The 2026-08-23 "documentation truth pass" (README corrected against HEAD: schema v1.1.0, installer gates, sync flags) is the strongest governance signal — a self-audit that fixed the docs rather than the tests. **What breaks first if velocity decays:** the release cadence (already 5 weeks stale at HEAD), then the nightly pin and the five sibling checkouts — a source build that requires exact sibling commits has no graceful degradation. Bus factor 1 [Verified, High].

---
## 4.9 NODUS factsheet

| Criterion | Score | One-line justification |
|---|---|---|
| Technology readiness (TRL 1–9) | **5–6** | Real engine, real releases, real installers, measured conformance — demonstrated in relevant environments (6-ish); but zero independent reproduction and no operational deployment evidence — 5 as a product |
| Strategic relevance (1–5) | **3** | Agent-local speech is a real strategic gap; capped by the rider (labs excluded), nightly-only toolchain, and whisper.cpp/API entrenchment |
| Impact potential (1–5) | **3** (4 if the Sortformer port certifies and the wasm32 target ships) | Speech market is entrenched; impact is methodological + the agent-orchestration wedge unless the native engine becomes the embeddable default |
| Implementation feasibility (1–5) | **4** | The core is built, released, and installer-packaged; what remains (certification, wasm32, release cadence, CI) is bounded |
| Time to mainstream (1–5) | **2** | Years minimum: needs independent validation, a second maintainer, release-cadence repair, and a license an enterprise can sign |
| Collaboration potential (1–5) | **2** | Source-available; rider blocks the two most likely AI-lab collaborators; bus factor 1; intra-suite coupling raises the contribution bar |

**Ring: Explore.** The ring rules are mechanical: *Invest* requires independent validation plus governance (neither exists); *Pilot* requires a release artifact plus a bounded real-workload fit. The release artifacts genuinely exist (v0.9.3 installables, Homebrew, model packages) — the closest any repo in this program has come to the Pilot line — but the latest release is five weeks behind HEAD, the CHANGELOG window is four weeks stale, there is no CI config in the tree, and zero independent validation exists; under "when in doubt, ring down, not up," this is **Explore**. Revisit triggers: a HEAD-current release, in-tree CI with a legible conformance gate, any independent benchmark or review, a second maintainer, or a license change.

## 4.10 Wardley placement

- **Speech-to-text inference (Whisper models on CPU):** Commodity — whisper.cpp and the APIs own it; franken_whisper's native engine adds leverage only via the ToMe lever and the evidence story, not via the capability itself.
- **Agent-first ASR orchestration (routing, NDJSON streaming, run persistence, replay):** Custom-built → early Product — works, released, installer-packaged; moves to Product with independent validation and a HEAD-current release.
- **In-process Rust Sortformer diarization:** Genesis → early Custom-built — no equivalent artifact (in-process, 4-lane, no Python/token); moves right if the port certifies on a public corpus, left into obscurity if it stays "development-uncertified."
- **Campaign-win bench doctrine + negative-evidence ledger + reward-hacking pattern catalog:** Custom-built — novel as a packaged discipline and the most transferable component; moves toward Product the moment a second project adopts it (see next step 1).
- **TTY audio transport over text-only channels:** Genesis — genuinely unusual (compressed audio + retransmission + adaptive bitrate over a PTY); moves right if the ffmpeg-dependent codec head is replaced and the replay invariants survive adversarial channels.

**The decoupling lens:** franken_whisper represents *engine-from-orchestration* (the native engine replacing the backends it once wrapped — the orchestrator became the engine vendor) and advances *measurement-from-claim* (the ledger as a machine that separates admissible numbers from inadmissible ones). It gestures only weakly at the next decoupling this research program has been tracking — *memory separating from the store*, with portable provenance-attested artifacts: the SQLite run history with replay envelopes is a proto-provenance record for transcriptions, but it attests pipeline outputs, not portable agent memory, and there is no origin binding.

## 4.11 Trajectory (12 / 24 / 60 months) — [Inference]

- **12 months:** continued high-velocity single-maintainer/agent work; probable HEAD-current releases resuming; the realtime `listen` driver certifies end-to-end (or the open `bd-rt-e2e-0zo5` bead stays open and the streaming story keeps its asterisk); Sortformer either certifies or is re-scoped; the wasm32 target either advances past the current 1,011-line beachhead or stalls. Stays in Explore unless independent validation lands.
- **24 months:** bifurcation. **Upside:** an independent benchmark or security review validates the core claims, a second maintainer or institutional adopter appears, the campaign-win doctrine gets adopted by a second project — Pilot for narrow workloads (agent sandbox transcription, auditable local STT). **Decay:** velocity slows with no successor; the pinned nightly (`nightly-2026-08-31`) ages past what the sibling pins support; the five sibling checkouts drift; the 366K-line tree becomes uncompilable from source and the releases go stale — the sibling-coupling failure mode (§4.7 weakness 7) is the concrete mechanism, not a metaphor — drifts to Monitor as a research artifact whose bench doctrine outlives its product.
- **60 months:** binary. Either a niche-but-real artifact (the memory-safe, evidence-carrying local speech substrate inside agent infrastructure — the lane nobody else is building), or superseded: whisper.cpp adds structured output and a router, an incumbent adopts token merging, and the "agent-first ASR" lane consolidates around whoever ships a release first with a clean license. The measurement methodology is the more likely survivor either way.

**Revisit triggers (concrete, observable):** a HEAD-current tagged release; CI configuration appearing in-tree with a legible conformance gate; any independent benchmark, code review, or production deployment; Sortformer certification on a public corpus; a second human maintainer with merge rights; the wasm32 native-engine target building; any change to the license rider.

## 4.12 Limitations and open questions (mandatory)

**Not done:** did not compile the workspace, run any test, start the binary, execute a transcription, reproduce any benchmark, attempt a release install, or run the conformance harness — all behavioral and performance claims rest on maintainer evidence plus revision-bound documentation. Shallow clone only (no history beyond HEAD). No CI pages to observe (no CI config in tree). Star/fork/contributor counts from the GitHub API (live, 2026-09-22). `#[test]` and `unsafe` counts are grep proxies (annotation count, code-line-leading-`unsafe` count). The 13-terminal-`FW-*` subset was not independently classified (35 unique codes counted; the terminal subset is a maintainer classification). Web search for independent coverage carries the usual recall caveats.

**Open questions that would most change the verdict:** whether the conformance harness actually runs on every commit (no CI to check); upstream-Tcl-equivalent pass/skip/fail counts for the native engine at HEAD; whether the Sortformer port's DER has ever been measured against a public corpus; whether any enterprise has evaluated the rider's legal exposure; funding and succession intentions of the maintainer; whether the five-week release gap is a pause or a pattern; what the real user count is (1 open issue, 93 stars, no user reports found); whether `fw-wasm` is a beachhead or a checkbox.

## The eight deepening questions (one paragraph each)

1. **Provenance.** The system records extensive provenance about *pipeline execution* — every run persists to SQLite with the full request, result, segments, pipeline events, evidence ledger entries, and a replay envelope carrying `input_content_hash` (SHA-256 of the normalized WAV), `output_payload_hash`, `backend_identity`, `backend_version`, and `pcm_sha256` (verified field names in `src/model.rs`) — but almost nothing about *who/what produced the audio or the models*: model packages are admitted by compiled SHA-256 trust roots (strong artifact identity), yet a transcription's replay envelope binds the pipeline's outputs, not the audio's origin [Verified machinery exists, High; behavioral claims Maintainer claim, Medium]. Making attestation portable would require hash-chaining the replay envelopes, signing them with an operator key, and binding the audio's origin at ingest time — the current envelopes are integrity records, not origin records, so a hostile operator could substitute audio and produce a valid-looking envelope for a different recording [Inference, Medium].

2. **The embeddable unit.** The smallest useful adoptable piece is the `native_engine` module (ggml parser + log-mel + BPE + transformer + greedy decode) or the FrankenTorch CPU kernels beneath it — the engine is OS-free synchronous Rust with platform dependence isolated behind `plat.rs`, which re-exports `std` on native targets and resolves to browser-safe shims (host-fed monotonic clock, serial `scope`) on wasm32 [Verified from `plat.rs` header, High]. The adoption cost is steep in practice: it lives inside a 297K-line single crate (you adopt the whole crate or vendor surgically), needs a pinned nightly (`#![feature(portable_simd)]`), hard-depends on the FrankenTorch sibling checkout at an exact commit (a Linux build fails without it), and the license rider follows every derivative — so embedding means vendoring nightly-only, rider-encumbered code with a sibling-checkout build step [Verified, High].

3. **Unexercised option value.** The architecture holds at least four unused capabilities: the sync, OS-free native engine is one `wasm32` target away from in-browser agent-local ASR (`fw-wasm/` is a 1,011-line beachhead: audio_decode, model, model_distribution — but not inference); the 5-stage rollout governance (Shadow→Sole) is a general safe-deployment pattern for any from-scratch engine, currently aimed only at itself; the FrankenJAX differential oracle (`fj-oracle` feature) is test-only machinery that could become a standing cross-implementation certification service; and the Bayesian router's alien-artifact contract could govern any adaptive controller, not just backend selection [Verified, High]. What unlocks them is, respectively, a wasm32 inference build, a documented decoupling of the rollout gates from Whisper specifics, a hosted oracle runner, and the router-export workstream — all product decisions, none blocked on research [Inference, Medium].

4. **Benchmark honesty.** The numbers most likely to survive an independent rerun are the *adverse and control* ones — the 2.273710× un-merged control row, the published non-verdicts (Metal kernel, failed A/A nulls), the 1.4–1.7× symphonia-over-ffmpeg normalize win — because they are the maintainer's own published non-wins and controls, and nobody publishes those unless the apparatus is real [Inference, Medium]. The 2.992045× flagship has the strongest method in the program but is load-bearing for the performance thesis *and* leans on ToMe token merging the incumbent cannot express; the README headline additionally pairs the flagship ratio with the control arm's better WER (0.010753 vs 0.025090). The thesis that survives without qualification is "1.5× on tiny.en at WER 0.0000, ~2.3× on turbo engineering-only, ~3× with an algorithmic lever" — strong, but a weaker slogan than the headline [Verified from ledger, High].

5. **The governance path.** The credible route from one maintainer to an institution runs through release cadence and CI: a HEAD-current release series plus a visible, legible conformance gate in-tree creates users, users file issues against real deployments, and a second maintainer emerges from the user base or from a company that depends on the agent-orchestration story — there is no shortcut, because today the newest code has no artifact and no gate a stranger can read [Inference, Medium]. What breaks first if velocity decays is the build itself: at 366K lines on a pinned nightly with five exact-commit sibling checkouts, a slowdown without a successor doesn't stabilize the project — it strands a tree nobody can compile from source within quarters, and the 5-week release gap at HEAD is the early warning [Inference, High].

6. **The license as strategy.** The rider excludes exactly OpenAI, L.L.C., Anthropic, PBC, their affiliates, and anyone acting for, benefiting, or under the direction of them — and defines "use" to include benchmarking, testing, analyzing, indexing, and training-data incorporation, with automatic termination and injunctive relief reserved to Jeffrey Emanuel [Verified verbatim, High]. As strategy it is coherent defensively and self-sabotaging offensively: the project's most credible future is agent speech infrastructure, the excluded parties *are* the agent-infrastructure builders, and the rider's breadth (even *analyzing* is forbidden) chills the independent validation the project most needs — the zero-independent-validation finding and the rider are plausibly cause and effect [Inference, Medium].

7. **Agent-era fit.** The concrete workload that would pick franken_whisper over whisper.cpp or an API is an agent loop needing local, private, structured speech-to-text: sequenced NDJSON events on a stable schema, 13 exact error codes instead of exit codes, Bayesian backend selection with a published decision contract, durable SQLite run history with replay envelopes for audit, and an in-process engine fast enough (1.5–3× the incumbent) to keep the whole thing one binary with no audio leaving the machine [Inference, Medium]. What would have to become true first: a HEAD-current release, an independent benchmark confirming the campaign rows, Sortformer certification (or an honest re-scope of the diarization default), and — unavoidably — a license an agent-platform company can actually sign [Inference, Medium].

8. **The kill test.** The single event that would falsify the core thesis — "an agent-first, evidence-carrying local speech stack is worth building" — is whisper.cpp (or faster-whisper) shipping the orchestration layer as a first-class feature: structured NDJSON output with a stable schema, exact error codes, and a backend-selection story, with institutional governance and a clean license, would commoditize franken_whisper's differentiation and leave it competing purely on the native engine — a fight where the ToMe lever is adoptable by the incumbent in one release [Inference, Medium]. The experimental falsifications are nearly as decisive: an independent rerun of the campaign rows on quiet hardware showing the wins don't reproduce outside the maintainer's workers, or a public-corpus evaluation showing the Sortformer port's DER above the acoustic-fallback baseline — either would collapse the two pillars (measured speed, native diarization) the product thesis stands on [Inference, Medium].

---

**Working notes:** clean shallow clone at `~/workspace/.scratch/franken_whisper-verify/` (HEAD `408b7e7`, 2026-09-22). No durable user-facing files created besides this assessment.