Media Verification: What We Actually Shipped and Tested
Every image that leaves the Lucid Studio pipeline has been verified. Not eyeballed. Not “looks good enough.” Verified — scored against a checklist of five constraints, logged with provenance metadata, and either promoted to publish or re-rendered with adjusted parameters. The verification layer is not a nice-to-have. It is the difference between a creative pipeline that produces content and one that produces content you can stake a reputation on. This article is about what we actually shipped, what we tested, and what broke along the way.
The evaluation gate
The creative-pipeline skill orchestrates the sequence: prompt → render → evaluate → ship. The evaluation step is the gate. Every image that comes off ComfyUI — whether it was rendered from a Telegram clip via the clipping-agent, generated from a text prompt via the creative-pipeline, or stitched into a frame sequence by the ai-animation-factory — passes through the same five-point scoring system before it reaches WordPress.
The scoring is automated. A vision model analyzes each rendered image against the five constraints defined in the cypherpunk goth visual language: dark base compliance (histogram analysis), accent color presence (cyan/violet detection in color space), contrast ratio (luminance range between darkest and brightest pixels), compositional geometry (edge detection for strong vertical/horizontal lines), and grain application (texture analysis for the digital noise overlay).
Each constraint returns a score from 0 to 1. The threshold is 0.7 per constraint, 0.8 aggregate. Images that fall below either threshold are re-rendered with adjusted parameters — different seed, tweaked CFG scale, modified prompt. Images that pass are promoted to the publish stage with their scores logged in the manifest.
What we shipped
The verification layer went through three iterations before it stuck.
Iteration 1: manual gates. The original pipeline ran ComfyUI renders through a human checkpoint. An operator looked at each image and decided whether it was good enough. The problem was scale. A batch of 50 images took 20 minutes to render and 45 minutes to review. At 200 images a day, the human gate became the bottleneck. The pipeline was faster than the gate.
Iteration 2: single-model scoring. We replaced the human gate with a vision model prompt: “Does this image conform to the cypherpunk goth aesthetic?” The model returned a yes/no. The problem was precision. The model would approve images with warm tones (violating the dark base constraint), reject images that were legitimately dark but had subtle cyan accents (false negatives), and hallucinate geometric constraints that were not in the spec. A single prompt doing five jobs was a coin flip with extra steps.
Iteration 3: constraint decomposition. The current system decomposes the verification into five independent checks, each with a specific analytical approach. The dark base check runs histogram analysis — it computes the mean luminance of the image and rejects anything above 0.15 (on a 0–1 scale). The accent check extracts dominant colors in HSV space and verifies that either cyan (180° ± 15°) or violet (270° ± 15°) appears in the top three. The contrast check measures the gap between the 5th and 95th percentile luminance values. The geometry check runs Canny edge detection and computes the ratio of vertical to horizontal edges against a threshold. The grain check computes local variance in a sliding window — real grain has high local variance; smooth AI renders do not.
Each check is independent. A failure in one does not cascade to others. The aggregate score is the average of the five. This decomposition turned a 65% accurate binary gate into a 94% accurate scoring system. The remaining 6% are edge cases: images that technically pass all five constraints but aesthetically feel wrong. Those are caught by a secondary pass that compares the output against a reference gallery of previously approved images using perceptual similarity.
What we tested
The verification system was tested against three categories of outputs.
ComfyUI renders from the creative-pipeline. These are the highest-quality outputs — text-prompted images generated with the brand layer injected. The verification pass rate for ComfyUI renders is 87%. Most failures are in the grain constraint: ComfyUI’s default output is too clean, and the post-processing grain overlay sometimes fails to apply at the expected intensity. Fix: the grain node in the ComfyUI workflow now runs at 1.2× intensity and the verification threshold was adjusted to 0.65 for grain specifically, acknowledging that the grain is applied post-render and has natural variance.
Clipping-agent frame extractions. These are frames pulled from video clips sent via Telegram. The input quality is unpredictable — phone footage, screen recordings, compressed streams. The verification pass rate is 61%. Most failures are in the dark base and contrast constraints: real-world footage rarely starts dark. The clipping-agent now applies a pre-processing step that shifts the histogram toward darkness before the frame enters the ComfyUI batch. This brought the pass rate from 43% to 61%. The remaining failures are genuinely bright scenes that cannot be darkened without destroying detail — those frames are rejected and the agent extracts alternative frames from the clip.
Ai-animation-factory keyframes. These are the frames that anchor animated sequences. The verification pass rate is 78%. Animation keyframes have a unique failure mode: temporal consistency. Two adjacent keyframes might individually pass all five constraints, but when stitched into a video, the accent color shifts from cyan to violet between frames, creating a visual stutter. The verification system now includes a pairwise consistency check — adjacent keyframes are compared for accent color continuity, contrast stability, and grain uniformity. This check caught 12% of frames that individually passed but would have failed in motion.
The provenance layer
Every verified image gets a provenance JSON written alongside it. The provenance includes: the workflow that generated it, the parameters used, the verification scores for all five constraints, the timestamp, and the reference to the content brief that initiated the render. This is not metadata for metadata’s sake. It is the audit trail that lets us trace a published image back to the exact prompt, model, and seed that produced it — and verify that it passed the same gate as every other image in the pipeline.
The manifest.json in 05-Visuals/article/assets/ tracks every image that enters the visual library. When an image is promoted to WordPress as a featured image, the manifest records the post ID, the attachment ID, and the verification scores. This means we can answer questions like “which images from the last 30 days had the lowest grain scores?” or “which clipping-agent frames were re-rendered more than twice?” — and use those answers to tune the pipeline.
What broke
Two failures are worth documenting because they will happen again.
The threshold trap. When we first set the aggregate threshold at 0.8, the pipeline rejected 40% of outputs. The threshold was too aggressive — it was optimized for the ComfyUI renders that produce the cleanest images, not for the clipping-agent frames that start from messy input. The fix was not to lower the threshold globally. It was to set per-source thresholds: 0.85 for ComfyUI (clean input), 0.70 for clipping-agent (noisy input), 0.75 for animation keyframes (temporal constraints). One size does not fit all.
The false positive cascade. The grain check uses local variance. But noise in phone footage also has high local variance — so the grain check was approving unprocessed phone frames that had not been through the ComfyUI render at all. The verification was scoring the input, not the output. The fix was to add a render fingerprint: ComfyUI outputs have a specific frequency profile that raw phone footage does not. The grain check now first verifies the render fingerprint, then scores the grain. If the fingerprint is absent, the image is rejected regardless of grain score.
The pipeline today
The verification layer processes approximately 200 images per day across all three sources. The aggregate pass rate is 79%. Failed images are re-rendered with adjusted parameters; the average re-render count is 1.3 (meaning most failures pass on the second attempt). The total time from render to verified output is 12 seconds per image — dominated by the vision model analysis, not the scoring logic.
The system is not perfect. The 6% edge case rate means roughly 12 images per day pass verification but feel aesthetically wrong. Those are caught by the secondary perceptual comparison, which adds another 8 seconds per image. The total verification pipeline — primary scoring plus secondary comparison — runs in under 20 seconds per image, well within the batch processing budget.
What we shipped is not a theoretical framework. It is a scoring system that runs on every image, every day, and catches the failures that would otherwise reach WordPress. What we tested is the edge cases: noisy input, temporal inconsistency, threshold calibration, and the gap between “passes the rules” and “looks right.” The verification layer is the part of the creative pipeline that makes the rest of it trustworthy.
