The Honest Instrument System
Anyone can stop a page from being copied. Almost nobody can stop it from being re-hosted — put back up somewhere else, under someone else's name, running someone else's business. That's the part we solve.
A scraper takes the site. It goes back up on another host, another domain, with the phone number changed. Now there are two of you, and only one is getting paid.
That isn't hypothetical — it's the ordinary outcome of automated scraping at scale, and it's the failure mode most protection never touches. Copy prevention doesn't help once the copy already exists somewhere you don't control.
Almost everything in this category writes a marker into a separate field — a meta tag, a comment, an embedded snippet. Those are containers. The content sits inside them, which means the field can be emptied and the content comes out the other side unchanged and unmarked.
This isn't a flaw in any one product. It's structural. If the mark lives in a slot, the slot can be cleared — and clearing slots is exactly the kind of work automation is good at.
The ownership mark is distributed through the structure of the work itself, not stored beside it. There is no field to find, so there is no field to clear. Removing the mark and damaging the page are the same operation.
You can't remove someone's DNA and have them walk away fine.
And the snippet isn't the lock. Strip the visible piece and the mark is still in there, and the site is still findable. That's the difference between one defense and three.
This isn't a clever trick. It rests on two results that have been settled science for decades, and they're worth understanding, because they are the reason the claim holds.
Claude Shannon, 1948. Information has an irreducible floor. You can strip out redundancy — repeated patterns, predictable structure, wasted space — but you cannot strip out information without destroying meaning. Every file has a hard lower bound, and it is a mathematical fact, not an engineering limitation.
That single result decides everything here. A marker sitting in a separable field is redundancy — free to delete, no information lost, content unharmed. A marker at the floor is not. You cannot take it out without taking content out with it.
Rolf Landauer, 1961. Information is physical. Erasing a single bit carries an unavoidable minimum energy cost — it is a thermodynamic act, not an abstract one. This was confirmed experimentally in 2012. Information isn't a label sitting on top of a thing. It is the thing.
So when someone asks whether the mark can be removed — that's the honest answer. Not "we made it very hard." There is no operation that removes it and leaves the work intact, because at that level those are the same operation.
This is a bold claim, and bold claims should come with someone's name on them.
Nearly 30 years as a network administrator. Production systems for Nissan, and for DXC — one of the largest IT companies in the world. In the room every time the network went down, handling the incidents, for years.
In 2007, an IVR system wired into a phone system that was already 45 years old — something that wasn't supposed to be possible. It ran for roughly 15 years with zero service calls before it was replaced. That was done before search engines could answer anything, which meant understanding the system all the way down, then writing the documentation everyone else learned from.
That's the background this comes out of — not a security product designed from the outside in, but a career spent underneath the box, on a problem nobody else bothered to fix.
“I would not give a fig for the simplicity on this side of complexity, but I would give my life for the simplicity on the other side of complexity.”
Oliver Wendell Holmes — the line I keep on everything I build.
TJ Bell
Defeating one doesn't get you anything. They check each other.
A mark is only worth as much as the thing that verifies it. Our verification core is being rebuilt in Rust — a systems language where whole categories of security failure aren't discouraged, they're impossible to write.
This is a problem the entire industry is working on right now, not a niche one. Rust is where serious teams have been moving security-critical code, and the reasons go beyond security — it's also why software feels fast instead of stuttering. What matters is that a memory-safe language is necessary but not sufficient. Even the largest teams ship real defects. What decides the outcome is whether the failure mode is safe by construction.
If anything goes wrong internally, the answer is denied — never allowed. That behavior is built into the structure, not left to a developer to remember.
Where this stands today: those figures are measured from the Rust core in testing, not from live traffic. The migration is underway and runs alongside the existing verified path until it is proven in production. We publish the status rather than the aspiration — that is what the word honest is doing in the name.
If they take your page, they take the DNA with it. That isn't a policy or a promise about how hard we'll try — it's structural. The mark isn't attached to the copy. It's part of what got copied. There is no version of taking your work that leaves it behind.
That nobody, ever, under any circumstances, gets past this. Anyone who tells you that is selling you something. A determined person with enough time and skill can do a great deal by hand — that was never what this is for.
What this stops is the automated, at-scale version — the mass scrape-and-repost that costs real businesses real money, and that no amount of care prevents on its own.
And all of it is testable. Take the code. Re-host it somewhere else. Do it a thousand times, however you like. It behaves identically every time, and you don't have to take our word for any of it — that's the whole point of an honest instrument.
Every company guarantees its product. A guarantee is a promise — and a promise is only ever worth as much as the company standing behind it. Companies fold. Terms get revised. Support windows close.
Ours isn't a promise.
Shannon proved information has a floor you cannot compress below without destroying meaning. Landauer proved erasing information is a physical act carrying an unavoidable energy cost. Those aren't our claims to make or withdraw — they're settled results, older than most of the software running on your machine, and they do not care who is making the copy, what tool they're using, or how clever anyone is feeling that day.
Your DNA is in that work because of how information behaves. Not because we said so. Not because we're watching. Because taking it out and destroying the work are, at that level, the same operation.
We don't just guarantee our product. We guarantee the laws of physics — and those work the same everywhere.
Watch a real clone get caught, live, on a copy hosted somewhere we don't control.
Go to the example →The Honest Instrument System and HTML Tree Lock are inventions of TJ Bell, Inventor and Co-Founder of PeakView.