The current stack — routed specialists on-device
Where the system stands as of August 2026, curated from my stack reference, audit notes, and campaign ledgers. Still pre-deployment, and still moving.
After v2.0, "the model" stopped being my unit of progress. What I ship is a system: a routed stack of calibrated experts over the warp foundation, fed by a data flywheel, gated by a single battery, and mirrored bit-for-bit on-device. A sketch I wrote back in v1 — "the future looks like tons of adversarial XGBoost models that are routed" — turned out to be roughly the architecture I shipped, with the crucial amendment that routing is by domain, and priors are stacked by precision rather than blended.
Anatomy of a verdict
INPUT IMAGE
│
CLRSignals (computed once)
capture signature · screenshot gate · dims
│
ROUTER — domain detector
hint > flat-UI gate > default(camera)
┌───────────────────┴───────────────────┐
domain = camera domain = screenshot
│ │
WARP BASE (patent core) SCREENSHOT EXPERT
per-tile round-trip residual DINOv2 content head
→ majority = tile-vote (warp is NOT trusted here —
→ weighted = saliency avg it false-fires on recompressed reels)
│
CAMERA FUSION head (XGBoost)
warp.weighted ⊕ DINOv2 ⊕ capture ⊕ sharpness
│
└───────────────────┬───────────────────┘
│
PRIOR STACK (compounds ↓)
capture-present → REAL (dominant: camera physics)
midjourney head → AI (fires only above a
[more specialists] high-precision threshold)
│
FINAL InferenceResult
weighted = compounded P → label · majority = warp anchor
specialists[] = every contribution, surfaced in the UII always report two numbers, and I designed the gap between them to be legible:
majority— the warp tile-vote. The pure camera-physics foundation, the patent anchor. Never overwritten.weighted— the compounded score the label is read from: warp → fusion → priors.
When they diverge, a specialist moved the verdict off the raw physics — and the UI shows exactly which one. This is stacking, not blending: I measured a naive feature combiner regressing real-image false-positives from 8% to 50–92%, where calibrated per-specialist outputs with high-precision priors hold it at ~0%.
What each layer is honestly worth
A layer-by-layer permutation audit let me put measured bounds on every component:
- Warp majority alone: a weak sensor detector, physics-capped at AUC ≈ 0.78–0.8 at every input size — presentation-robust (no resolution noise-floor down to small inputs) but ceiling-limited. It is the anchor, not the verdict.
- Fusion base probability: 0.94–0.97 with ~0% false positives on genuine cameras — the base was already hardened; my gains live in data, not warp tweaks.
- Downscale fragility belongs to the capture channel (86% of adjacent-rung verdict flips), not warp (5%) — so I put my robustness work where the flips are.
The flywheel — coverage as an operating system
I turned v2.0's conclusion ("generalization = in-distribution data") into infrastructure:
daily scrape → ingest AS FEATURES → weekly warm-start retrain → STAGE → full battery → promote- Feature store, not images. All my retrains read stored feature vectors (DINOv2 embeddings, warp scalars, capture features); images are transient. I delete NSFW imagery outright and preserve only features — a privacy and liability posture, not just hygiene.
- Warm-start is load-bearing. Continuing the deployed booster on new generations moved blind-spot recall 86% → 99% while preserving fragile decision boundaries; from-scratch store retrains failed to reproduce those boundaries on me five separate times. The deployed model is an artifact of its history.
- One battery. A single spec + runner over a fixed set of anchor cases replaced the four divergent gate implementations I'd accumulated. My law of the land: full battery after every promote — instituted after a promote-path bug shipped me a silent no-op deploy.
- Heads are the scaling unit. A new specialist = a linear head on the shared DINOv2 embedding + a prior entry. I retrain no base and touch no other head. A few kilobytes of priors per generator family.
The provenance turn
The second consequence of v2.0: if pixel-space invariance is bounded, I should move where the signal is stronger.
- Container provenance (v2.3). The byte-level structure of the JPEG container itself signs raw camera captures at AUC 0.998 (0.993 metadata-stripped). Not an AI detector — a trust tier. It pairs with the capture signature as the "this is a camera original" side of the product.
- Capture-present as dominant prior. Real reels keep the sensor signature ~83% of the time; AI reels ~0%. As a prior rather than a feature, it is the single most decisive component in the stack — and an adjudicated field case taught me the corollary: when the stack was right and my UI surfaced the raw physics vote instead, the compounded verdict is what I should have been surfacing.
The current research edge (v2.4 → v2.7)
- v2.4 — the shipped regime. A leaner, hardened warp configuration under a fusion head at image AUC 0.922, with exact Python↔Swift parity (down to convolution-kernel and angle-convention gotchas).
- v2.6 — directional signatures. My per-tile directional-response concept produced a 4×-replicated external gain (+0.13) on the hardest wild negatives, then survived a true-parity coupled-ship analysis before shipping — and held.
- v2.7 — WarpGAN. A pix2pix student distills the warp tile-probability field (the first ONNX model in the repo). The GAN student beat its teacher (majority 0.770 vs 0.755), and its mean-probability aggregation crossed the warp ceiling — making aggregation, not epochs, my next lever. I refuted the anomaly-detection route (one-class GANomaly on tiles) at 0.526: cross-tile context and supervision are both load-bearing.
- Wild-data truth. A live X (Twitter) harness with human-adjudicated ground truth (~1,088 media) keeps my battery honest — including the humbling adjudication where my own anchor "AI lion" turned out to be a real 2015 photograph by Atif Saeed. The truth-fix ship that followed passed the full battery with the hardest real anchor passing for the first time.
On-device
The whole stack ships in an MLX-Swift package: I reimplemented DINOv2 in MLX, ported the warp pipeline with cv2-exact fidelity, and bundled fusion + heads as resources in one shared package for macOS and iOS. Every layer is commercially clean: warp, capture, container, and gates are mine; DINOv2 and XGBoost are Apache-2.0; MLX is MIT. Verdicts are computed on the user's hardware — no image ever needs to leave the device, which, as I argue in chapter 7, is not an implementation detail but the point.
You can put this stack to work yourself at obscur.rao.nyc — same routing, same priors, same two numbers described above.
But everything here has only ever passed my own battery. None of it has met a proper deployment yet — real users, real adversaries, real volume — and that is a different class of problem from the ones in this chapter. It is also the next one.