What the AI can find

Every detector, what it is good at, and where it is not.

Cullstack's AI exists to narrow a shoot down, not to decide for you. Each detector adds a filter you can combine with ratings, flags and colour labels, so you can ask for something like "photos with people, no closed eyes, not blurry" and cull what is left.

All of it runs on your own machine. The models are optional downloads that install from Settings → AI → Plug-Ins, and no photo, thumbnail or result is ever sent anywhere. Nothing here needs an internet connection once the models are installed.

Everything on this page is a Pro feature. See pricing for what each tier includes; the 30-day trial covers all of it.

Search your photos by describing them

Type what you are looking for and Cullstack ranks the shoot by how well each frame matches. It understands scenes and actions, not just objects, so ordinary language works: a bride and groom kissing, a group photo of guests, a church interior, a black and white photo.

Where it falls down: it understands scenes, not individuals. It will find "bride in a wedding dress" but not a specific person by name, and it cannot count. For "which photos have exactly three people", use person detection instead.

Faces

Find faces

Locates every face in a frame along with the eyes, nose and mouth corners. This is the foundation the other face features build on, so it needs to be installed for closed-eye detection and person identity to work.

Find this person

Turns each face into a mathematical fingerprint, so you can pick one face and pull every other frame containing that person. It is also what stack-by-face uses to group a shoot by who is in each photo.

Where it falls down: identical twins, heavy occlusion, and large age gaps between photos all weaken the match. Cullstack never stores a name, only the fingerprint.

Closed eyes

Flags the frames where someone blinked. Cullstack has three ways of doing this and uses them in the order we measured to work, not the order the research suggests: a dedicated classifier first, with two landmark-based methods as fallbacks.

Worth knowing: we tested all three approaches against hand-labelled photos. The classifier found every closed eye; the blendshape fallback found 28%; the geometric method found none. The geometric approach is popular because it works well on video, where it sees a close-cropped face many times a second. In a full-frame photograph an eye is only a few pixels across. If you install one model for this, install the classifier.

People and objects

Find people

Detects whole bodies rather than faces, so it still works when someone is turned away, walking out of frame, or too far off for a face to register.

Quality

Blur and quality

Flags frames that are soft, out of focus, or motion blurred. This one needs no download and is not a neural network at all: it combines a perceptual sharpness score with a check for whether anything in the frame is sharp.

Why it is built this way: that second half is what stops it flagging portraits with deliberately blurred backgrounds. A tack-sharp face with creamy bokeh still has one very sharp region; a camera-shake frame has none anywhere. The modern deep-learning quality models are all trained on datasets that forbid commercial use, so the classical approach is the one we can legitimately give you.

Content

Explicit content

Scores each photo for explicit content so boudoir, nude or personal work can be flagged and kept out of a client-facing export or a slideshow.

Where it falls down: it is a triage signal, not a judgement. Fine art nudes, medical images and swimwear sit in genuinely ambiguous territory and it will get some of them wrong in both directions. Nothing is ever deleted or hidden on its say-so.

AI-generated images

Answers whether a file came from a camera or a generator. Cullstack checks metadata first, because many generators write their own tags and that answer is certain. The model is the fallback for when metadata has been stripped.

Where it falls down: no detector available today is reliable on images specifically crafted to fool people, and published benchmarks put the best of them near chance on that category. Treat a flag as worth a look, not as proof.

Putting them together

The detectors are more useful combined than alone. A workflow that suits a large wedding or event shoot:

• Filter out blurry frames first, since those decisions are never close.
• Split people from venue and detail shots with person detection.
• On the group shots, flag closed eyes and work through the bursts.
• Use search for the specific moments you know you need: the cake, the first dance, the confetti.
• Use "find this person" at the end to check nobody important is missing.

Installing the models

Settings → AI → Plug-Ins lists every model with its licence and source, and installs each with one click. Install only the ones you need; each feature simply stays off until its model is present, and nothing else is affected.

If you would rather fetch a model yourself, drop the file onto its row and Cullstack renames it into place. The model reference below lists the exact filenames and the licence of each model.

Model reference

The detail behind the one-click installs: which model each feature uses, its licence, where it comes from, and what to do if you would rather install your own. Most people never need this page; it is here because the people who do need it need all of it.

Which AI models does Cullstack use, and where do I get them?

Cullstack ships without bundled AI models: each feature is opt-in, and you choose the model that fits your workflow (size, accuracy, license). Every model below is one click in Settings → AI → Plug-Ins, which downloads it and puts it in the right place under the right name. You can also install one yourself: models live in ~/.cullstack/models/, and dropping a file on its row in Plug-Ins renames it for you.

Important for commercial users: Cullstack itself is commercial software. Match each model's license before installing. Permissive licenses (Apache 2.0, MIT, CC-BY-4.0) allow commercial use with attribution. NonCommercial (CC-BY-NC) and strong copyleft (AGPL) licenses can be problematic for paid users running professional photography businesses. When in doubt, check with the model author or a lawyer.

For a plain-language guide to what each detector finds, how to use it while culling, and where it gets things wrong, see the sections above.

What each model actually does

The table above says which file goes where. This is what each one is doing with your photos, and where each one falls short, so you can decide which are worth installing.

Face detection (face_yunet.onnx, 224 KB)

Finds faces and returns a box plus five landmarks: both pupils, the nose tip and the two mouth corners. It is the foundation for everything else face-related, so the identity, closed-eye and blink features all need it installed. It is tiny and quick, around 10 ms for a full frame, which is why it can run across a whole shoot without being a batch job.
Limit: it finds faces, not who they belong to. Faces turned well away from camera or very small in frame are missed.

Find this person (face_embed.onnx, 37 MB)

Turns a face into a list of 512 numbers chosen so that two photos of the same person land close together and two different people land far apart. Cullstack never stores a name or an identity, only that list of numbers, and comparing two of them is what powers "find this person" and stack-by-face. It is trained specifically on faces, which is why it is far better at this than general image similarity.
Limit: identical twins, heavy occlusion, and a decade of age difference between two shots all reduce the match.

Closed-eye detection (eye_state.onnx, 328 MB, plus two optional helpers)

Crops a small square around each pupil and classifies it as open or closed, so you can flag the frame where someone blinked. Cullstack has three ways to do this and tries them in the order that actually works rather than the order the research literature suggests. The dedicated classifier goes first. Two optional models, face_mesh.onnx and face_blendshapes.onnx, provide fallbacks based on facial landmark geometry.
Why that order: we measured all three against hand-labelled photos. The classifier caught every closed eye. The blendshape fallback caught 28%. The geometric one caught none. The geometric method is popular because it works well on video, where it sees a close-cropped face many times a second; in a full-frame photograph an eye is only a few pixels across and the measurement is mostly noise. If you only install one, install the classifier.

Blur and quality flagging (no download, built in)

Flags frames that are soft, out of focus, or motion blurred. This one is not a neural network at all and needs no download: it combines a perceptual sharpness score with a check for whether anything in the frame is sharp. That second half is what keeps it from flagging portraits with deliberately blurred backgrounds, since a photo with a tack-sharp face and creamy bokeh still has one very sharp region, while a camera-shake frame has none anywhere.
Why no deep model: the modern deep-learning quality models are trained on research datasets that forbid commercial use, so shipping one in a paid app is not an option. The classical approach is the one we can legitimately give you.

Semantic search (CLIP, two files, ~350 MB)

Lets you type "sunset over water" and get matching frames without having tagged anything. Two models put images and text into the same mathematical space, so a photo of a sunset and the words "sunset over water" land near each other and can be compared directly. The same similarity powers auto-stacking by visual likeness.
Limit: it understands scenes and objects, not specifics. It will find "bride and groom kissing" but not "the Hendersons".

Person detection (person_detect.onnx, 34 MB)

Finds whole people rather than faces, so it still works when someone is turned away, walking out of frame, or too far off for a face to register. Useful for splitting a shoot into frames with people and frames without.
Note: this uses YOLOX, which is Apache 2.0 and free for commercial use. Older versions of Cullstack pointed at YOLOv8, which is licensed in a way that creates real problems for a working photography business. If you installed that one by hand it still works, but the current download is the one you want.

NSFW flagging (nsfw.onnx, 328 MB)

Scores each photo for explicit content so boudoir, nude or personal work can be flagged and kept out of a client-facing export or a slideshow. It is a general image classifier trained on that distinction.
Limit: it is a triage signal, not a judgement. Fine art nudes, medical images and swimwear sit in genuinely ambiguous territory, and it will get some of them wrong in both directions. Nothing is deleted or hidden on its say-so.

AI-generated image detection (ai-detector.onnx, 83 MB)

Answers "was this made by a camera or by a generator?". Cullstack checks metadata first, because many generators write their own tags and that answer is certain. This model is the fallback for when the metadata has been stripped. It was trained on 2.7 million images from 4,803 different generators, so it generalises to tools that did not exist when it was built.
Limit: no detector available today is reliable on images specifically crafted to fool people, and published benchmarks put the best of them near chance on that category. Treat a flag as worth a look, not as proof.

All inference runs on your machine via ONNX Runtime, so no photos or model outputs leave the computer. Each feature no-ops gracefully if its model is not installed, so you can try one at a time without disrupting the rest of the app.

How do I enable the visual AI classifier for the last 10%?

Open Settings → AI → Plug-Ins and click Install on the AI-image detection row. That is the whole procedure. The classifier is opt-in rather than always-on, so it stays off until you ask for it, and no model is bundled in the installer.

The model is OwensLab/commfor-model-384 (“Community Forensics”, CVPR 2025, MIT): a 87 MB Vision Transformer trained on 2.7 million images from 4,803 different generators, which is why it still recognises tools that did not exist when it was trained. We host the converted ONNX because the authors publish PyTorch weights only, with the licence and notice beside it.

How it behaves on real photographs. Measured on 309 ordinary photos here — family snaps, a wedding, travel — the median score was 0.01 and two frames crossed the 0.85 threshold, both heavily recompressed phone-messenger images. On a set of AI-generated headshots every one scored 1.00. Recompression is the known weak spot: squeezing a photo to a few tens of kilobytes destroys the sensor noise the model reads.

1. Pick a model. OwensLab/commfor-model-384 is what the Install button fetches, so you only need this section if you want something else. dima806/ai_vs_real_image_detection and dima806/ai_vs_real_image_detection and Organika/sdxl-detector are the ones people ask about. The first is Apache-2.0 but trained on an older generation of image models, so it is not an upgrade; the second is CC-BY-NC-3.0, non-commercial only, and so not usable in a paid Cullstack workflow.
2. Convert to ONNX with HuggingFace's optimum toolkit. One-time Python setup, then one command per model:

   # One-time
   pip install "optimum[onnxruntime]" transformers
   
   # Convert
   optimum-cli export onnx \
       --model <the model you picked> \
       --task image-classification \
       ~/Downloads/ai-detector-export/
   
   # Move into Cullstack's models folder
   mkdir -p ~/.cullstack/models
   mv ~/Downloads/ai-detector-export/model.onnx \
      ~/.cullstack/models/ai-detector.onnx

   optimum-cli downloads the PyTorch weights from HuggingFace, traces them through a representative input, and emits an equivalent ONNX. The resulting file works with the same AIImageDetector code in Cullstack.
3. (Optional) Verify in Cullstack. Open Settings → AI and confirm "AI image detector model: Installed". If you'd rather use the file picker than the command line in step 2, run optimum-cli with a different output folder and then in Cullstack click Install ONNX model… to copy the file in.
4. Each scanned file is classified once and the verdict is cached, so the new AI badges appear on previously-uncaught photos immediately and stay there across restarts.

Using a different model instead: any HuggingFace-style ONNX image classifier with a 1-output sigmoid, 2-class softmax (real / AI), or N-class softmax works — Cullstack reads both the input size and the output shape from the model. One catch: pixels are passed as plain RGB scaled to 0–1, so a model that expects ImageNet mean/std normalisation must have it folded into its ONNX export, or its scores will be meaningless rather than obviously wrong.

License compliance: the model's license is between you and the model author when you download from HuggingFace. Check the license on the model's HuggingFace page before installing: Cullstack is commercial software ($99/yr Standard, $179/yr Pro), so models with a NonCommercial clause (e.g. CC-BY-NC) are off-limits for paid users running professional photography businesses. Permissive licenses (Apache 2.0, MIT, CC-BY-4.0) allow commercial use with attribution and are the safe pick. Inference runs entirely on your machine, so no photos or detection results leave your computer.

Can I use a different AI image detector? Commercial, specialized, custom-trained?

Yes. Cullstack's AI image detector is model-agnostic, whatever .onnx file lives at ~/.cullstack/models/ai-detector.onnx is what Cullstack uses. The shipped install flow (Settings → AI → "Install ONNX model…") copies any compatible model into that slot, so swapping in a different detector is a 5-second operation. No code change in Cullstack, no support ticket, no reinstall.

Compatibility envelope: any ONNX image classifier that accepts a 3×224×224 RGB tensor and outputs 1, 2, or N classes is supported automatically, because Cullstack inspects the model's input/output shapes at load time and adapts. Most modern transformer + CNN classifiers fit this envelope out of the box (ViT, Swin, ConvNeXt, ResNet, EfficientNet, MobileNet, etc.).

Common substitution paths and who they're for:

• Free HuggingFace models: covered in the "How do I enable the visual AI classifier" FAQ above. Best starting point for most users.
• Commercial detectors with budget: services like Hive AI, Reality Defender, Sensity, etc. sell paid AI- detection models. If they offer an ONNX or PyTorch export (ask their sales team, since many will export for self-hosting customers), Cullstack runs the inference locally with the same install flow. Useful for studios that need higher accuracy than open-source models provide, or that need contractual SLAs on detection quality.
• Generator-specific detectors: fine-tuned for one tool (Midjourney-only, SDXL-only, deepfake-specific face detectors). Useful when your library contains a predictable AI source, for example concept-art studios reviewing junior submissions against a known Midjourney pipeline. Search HuggingFace for keywords like midjourney detector, sdxl detector, deepfake detection.
• Custom-trained models: ML engineers and large studios sometimes train their own detectors on proprietary data (their own historical archive vs. their AI tool's output, for example). Export from PyTorch / TensorFlow with torch.onnx.export or tf2onnx, drop into Cullstack. The model never touches Cullstack's servers (we don't have any AI-related servers).
• Multiple models, one workflow: Cullstack only loads one detector at a time, but you can swap them in and out instantly. A wedding photographer might run a general classifier on import day, then swap to a Midjourney- specific one when auditing a concept-art folder. The per-file verdict cache is keyed to file path + mtime, so the old verdicts are kept; only files that haven't been scanned yet by the new model get re-classified.

On the threshold: the visual classifier's confidence threshold is fixed at 0.85 to prevent casual false-positive floods, and there is currently no supported way to change it. It is not exposed in Settings, and the underlying Java preference cannot reliably be set from outside the app. If you have a research use case for tuning it, email support@aviastone.com and we will look at exposing it properly.

Confidence floors below ~0.70 substantially increase false- positive risk on real photography, so it is recommended only for researchers comparing classifier behavior, not for production photo culling.

What Cullstack doesn't do: validate model accuracy, vouch for vendors, or take responsibility for misclassification consequences. The model is your choice, the license is between you and the model author, and the downstream decisions (delivering, flagging, deleting) are always your call. Cullstack is the tool; you are the photographer.