Safer by design, not safer by luck.
Harmful content doesn't wait to be uploaded. It doesn't announce itself. It appears in a browser, a messaging app, a camera preview, a livestream, a screenshot passed quietly from one device to another.
For years, the world's answer has been to wait. Scan what gets uploaded. Flag what gets reported. Remove what gets found, eventually. That model has done some good we want to be fair about that. But it has never stopped harm from starting, and it never will. Because by the time content reaches a server, a child has often already seen it.
We believe children deserve better than a system built on ‘afterwards’. So we built something different - a new model of safeguarding altogether. This is the story of what that model is, and why we're convinced it's the best way forward.
The problem with waiting
Many safeguarding tools the industry has relied on shares one unavoidable flaw: it works after the fact. A harmful image has to be uploaded before it can be flagged. A conversation has to be reported before anyone reviews it. A child has to already be exposed before anything happens at all.
That delay is the whole problem. Every move a harmful file makes from device to server to another device is another chance for it to be forwarded, screenshotted, and copied beyond anyone's reach. Once it's out, it's out. No takedown request can undo what a child has already seen.
And there's a second flaw, one that's talked about less. Almost all of today's protection lives at the surface. An app here, a filter there, a setting a busy parent has to find, install, and configure. Apps can be deleted. Filters can be switched off. Settings can be sidestepped by a determined twelve-year-old in about four minutes. Surface-layer protection asks families to build their own safety, piece by piece, on top of devices that were never designed to be safe.
We asked ourselves a simple question: what if the device itself was safer? Not safe because of what's bolted on top, but safer by design - protection woven into the foundations, beneath the apps, working everywhere, all the time?
That question became HarmBlock.
Moving protection to where the harm happens
HarmBlock is SafeToNet's on-device safeguarding AI, and it's built on a belief we didn't borrow from anyone else's playbook: protection has to live where the harm actually happens. On the device. In real time. Before a single frame is filmed, seen, or shared - not after.
Instead of asking "was this harmful?" once it's too late to matter, HarmBlock asks the question at the only moment the answer can still change anything: before the content ever appears on a screen or leaves a camera. Because it sits below the surface layer, beneath the apps, at the level of the device itself. There's no app to delete, no setting to find, no gap between one platform's rules and another's. The protection is simply there, the way a seatbelt is there, quietly doing its job wherever the journey goes.
Privacy and protection were never really at odds
The most common worry we hear is that on-device detection is a slippery slope to having your personal information collected. It's a fair worry, and we don't dismiss it. The industry has earned plenty of scepticism. But it mistakes one architecture for another.
Cloud scanning needs your content to be visible somewhere: decrypted, inspected, stored, accessible. We deliberately built HarmBlock the opposite way. All visual analysis happens locally, on the device, using our own model. It’s not a call out to a remote service, not a database of everyone's content sitting on our servers. Nothing needs to be sent anywhere for a decision to be made. HarmBlock returns a narrowly scoped safeguarding signal and nothing else. No behavioural profile, no record of a child's habits, no images, no scores left behind once the decision is made.
Done this way, on-device protection is more private than the cloud alternative, not less, because it removes the need for anyone's content to sit on a central server just to protect the children who need protecting.
We weren't willing to choose between privacy and safety. So we didn't. We built something harder instead.
Built for the world that's coming, and the one that's passing
Encryption is becoming the default and we welcome that. As more platforms encrypt content end-to-end, cloud-side scanning simply runs out of things it can see. HarmBlock never needed the cloud in the first place, so it works inside end-to-end encrypted environments just as it does anywhere else. It doesn't lose ground as encryption spreads; it was designed for exactly this direction of travel.
Known-image matching was already behind, so we didn't build on it. Most cloud-based detection checks content against a list of previously identified images powerful against known material, blind to anything new. HarmBlock is different: it recognises what an image actually depicts, which means it can catch newly created or modified material that would walk straight past a database of the past. As generative tools make new variations trivial to produce, that distinction matters more every day.
Harm doesn't wait in a queue, and neither does HarmBlock. Reported content can sit unreviewed for hours or days elsewhere. A child in an unsafe moment doesn't have hours or days. HarmBlock makes its decision at the point of creation or receipt that's the entire point of living on the device instead of in a review queue.
Safer by design - our way forward
The industry has spent years treating child safety as a moderation problem: something to fix with faster reviews and bigger trust-and-safety teams. That work matters, and the people doing it deserve respect. But it's built on a foundation that gives harm a head start, every single time.
We chose not to build on that foundation. We chose to build a new one a layer of protection inside the device itself, beneath every app, present from the moment the device is switched on. Devices that are safer by design, so that safety stops being something families have to assemble and starts being something they can simply trust.
We can't allow digital harm to thrive in darkness, isolation, and silence, waiting for someone to notice after the damage is done. So HarmBlock doesn't wait. It moves protection to where the risk actually starts onto the device, into the moment, before the harm happens rather than after.
If you're a tech company, we'd love to talk about building HarmBlock into your devices. If you're a policymaker, help us make this approach the standard, not the exception. If you're a parent we built this for your child, and we're here.
The internet should be a place of wonder, not worry. This is our answer to how that actually gets built.