When a human checks whether two photos show the same person, they just look. When a pipeline needs to check ten thousand times without getting tired or generous, it needs a number. That number comes from face-recognition technology — most commonly ArcFace — and it's the quality gate that separates rigorous AI-character pipelines from hopeful ones.
The core idea: faces as coordinates
A face-recognition model takes a photo and outputs an embedding — a list of a few hundred numbers that encode the geometry of identity: eye spacing, jaw structure, nose bridge, the proportions that make a face that face. Crucially, the model is trained so that photos of the same person land close together in this number-space even across different angles, lighting, expressions, and haircuts — while photos of different people land far apart.
That training objective is the magic. The embedding learns to ignore the things that vary between photos of one person and amplify the things that vary between people.
From embeddings to a yes/no gate
Comparing two faces becomes arithmetic: compute both embeddings, measure the cosine similarity between them (roughly: the angle between two arrows in that space). Same person → high similarity. Different person → low. Pick a threshold, and "does this look like her?" becomes a pass/fail test you can run on every image automatically.
In an AI character pipeline, the comparison anchor is the seed image — the canonical photo of the character. Every generated reference candidate is scored against it:
- Generate ~50–100 reference candidates from the seed.
- Embed each candidate, score against the seed's embedding.
- Auto-reject anything below threshold — the drifters.
- Hand the survivors to a human for the taste pass, then lock the golden set.
This matters because generated references will drift — the generator is re-rendering the person from one example, and some fraction comes back as a convincing stranger. Un-filtered, those strangers enter the reference library and every future image conditioned on them inherits the error. The filter catches drift before it compounds.
What the number can't see
Honest limits, because they explain why pipelines keep a human curation step:
- No face, no score. Back-of-head and heavily occluded shots can't be embedded; a pipeline keeps them (hair and silhouette data is valuable) but flags them as unscored.
- Identity ≠ aesthetics. A reference can be verifiably the same person and still be a bad photo — weird hand, mangled background, off-brand styling. The machine gates who; the human gates good.
- Thresholds trade off. Too strict rejects legitimate variety (profiles score lower than frontals by nature); too loose admits near-misses. Production systems tune the threshold against the seed's angle and keep humans in the loop near the boundary.
Why you should care as a non-engineer
When evaluating any AI character tool, the question is: "how does it verify references are the same person?" If the answer is "the model is just good" — that's hope, not engineering. Drift is statistical; at 50+ reference images, some will be off, and only measurement catches them.
AI CMO runs ArcFace scoring (via a local inference sidecar — face data never leaves the pipeline for a third-party API) on every generated reference, auto-rejects below-threshold images, and shows you the survivors for one curation pass. The result is a library where every scoreable image has been mathematically verified against your seed — which is what "her face never changes" actually requires. See it run on your own character — $19.