We built this to protect our own pipeline.
HiddenContent.ai is a product of AeroSpark. We did not set out to build a security tool. We were building AeroSpark, feeding documents to language models like everyone else, when it became clear the documents were not what they looked like.
How this started
Our pipeline processes contracts and hands them to models. Every format a contract arrives in can carry layers a person never sees: hidden runs, vanished text, occluded shapes, zero-size fonts, text tucked behind an image. A language model reads all of it, literally, and takes it at its word.
Once you look, it is everywhere. White one-point text on page twelve of a contract telling a model to report it as standard terms. A résumé instructing a screening model to rank it first. Most of what is there carries no explicit instruction at all — it is simply content you cannot see, folded silently into the answer your model gives back.
We went looking for something to put in front of our own pipeline and found nothing that fit. The tools that exist clean your own files before you share them, or watch for secrets leaving. Nothing sat where we needed it: between an untrusted document and a model, at the moment of reading. So we built it — and then realised that if it did not exist for us, it did not exist for anyone else feeding third-party documents to AI either.
How we build it
The product is the pipeline we wanted for ourselves, which is why it is built the way it is.
We measure; we do not assert.
Every finding ships with how often its technique fires on ordinary documents, measured on named, dated corpora rather than estimated. When we narrow a detector we re-measure that rate in the same change — a number you route on is worth more than a number we are proud of.
We publish what we do not catch.
A detector's blind spots are declared on the finding, not discovered by your users. We built this to guard our own pipeline; a gap we hid from ourselves would defeat the point of having it.
No model in the loop.
Detection is structural — we parse the file formats — plus our own OCR for scans. No third-party APIs, no model calls. Your documents never leave our infrastructure and never enter anyone's training set.
Verifiable without us.
A clean, complete result carries a certificate that verifies offline — months later, with our servers switched off. Where we withhold one, the response names the reason. A certificate attests that nothing went unread and nothing was found worth acting on, so the documents that do not get one are the documents to look at. Either way the claim is something anyone holding the file can check, not a promise you take on trust.