← The CLR Journey

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

text
                          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 UI

I 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:

text
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.

A note on the data. The flywheel collects publicly posted media to learn what generated imagery looks like in the wild. Images are transient, only derived feature vectors are stored, nothing is reproduced or served back, and the output is a verdict about an image — never a new work built from someone else's. That is the line I draw in Fair Use.

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.