The arrival of capable AI has forced us to re-examine some words we thought were settled. "Responsibility" is the one that keeps surfacing — because a machine can now do a great deal, and yet it can never answer for any of it.
Here is a definition worth keeping: to be responsible for something is, ultimately, to agree to pay the price if it goes wrong. Not to take credit when it goes right — anyone will do that — but to stand exposed to the consequences when it doesn't. A surgeon, an auditor, an engineer who signs a structural drawing: each of them carries something that can be lost — a license, a reputation, a livelihood — if their judgment fails.
Why a machine can never be responsible
By that definition, a machine cannot be responsible for anything, and never will be. Not because it isn't capable — it may be more capable than the person reviewing it — but because it has no stake to forfeit. You cannot fine it, sue it, suspend its license, or shame it in front of a client. It has nothing to lose, which is precisely what "being responsible" requires you to have.
This isn't a temporary gap that better models will close. It's structural. Accountability needs a bearer who can absorb the cost of being wrong. A model has no such capacity. So the question is never "is the AI responsible for this output?" — it can't be — but "who is?"
And the answer, every time, is a person.
"Report by Oliver Vogt" becomes "Report prepared and reviewed by Oliver Vogt"
The change isn't cosmetic. When Oliver Vogt produces an analysis with AI assistance, he didn't write it by hand. Crediting with a bare "report by" would misrepresent what happened. But crediting "the AI" would be worse — it points the credit, and with it the accountability, at something that can hold neither.
Both verbs belong to Oliver Vogt. The AI generated the raw output; the human prepared it — steering the model toward the right answer, checking the layout, shaping it into something fit to send — and then reviewed it. The machine didn't prepare anything; a person did, and then stood behind the result. That's the one thing the machine can't do — put a name to it. So the line isn't a marketing flourish; it's an accurate description of where the responsibility sits.
You cannot vouch for something blindly
Here is where the philosophy turns into a design requirement.
To vouch for something is to lend it your credibility — to say "I stand behind this." But you can only lend credibility you've earned the right to lend. If you vouch for an output you never looked at, you're not being responsible; you're gambling with your name and hoping the machine was right. The moment it isn't, you discover you never had the standing to vouch in the first place.
Vouching therefore carries a minimum: you have to at least spot-check. Not necessarily re-derive every line — that would defeat the point of using AI at all — but verify enough to genuinely stand behind the result. A reviewer who signs without looking has reduced "reviewed by" back to a lie.
That single requirement — that vouching demands at least a look — is what forces a human into the loop. Not a checkbox, not a disclaimer in the EULA, but an actual person who reads enough of the output to mean it when they put their name on it.
Why this matters most in anonymization
Anonymization is exactly the kind of task where a confident, unsupervised machine is most dangerous — because its mistakes are silent. When detection misses a name, nothing breaks, no error appears, no alarm sounds. The document simply leaves the building with a real identity still in it, and you find out only when it's already somewhere you can't recall it from.
A fully automatic anonymizer asks you to trust, at volume and without looking, that it caught everything. But "it probably caught everything" is not a position you can responsibly vouch for — and a single miss is the whole failure. The asymmetry is brutal: ninety-nine correct redactions don't compensate for the one name that slipped through.
This is why, at promptShield, we believe responsible anonymization has to be a semi-automated process — not because the automation is weak, but because the responsibility cannot be automated away.
How promptShield keeps the human in the loop
The automation does the heavy lifting. A three-layer pipeline — regex, named-entity recognition, and an optional local model — runs entirely on your machine and proposes every detection it finds, links recurring entities across pages, and filters obvious noise. On a long document this is the difference between minutes and hours.
But it proposes; it doesn't decide. Every detection is shown to you as a reviewable region you can confirm, adjust, add, or remove. You see what's about to be redacted before anything is committed. The tokenized result ([PERSON_1], [ADDRESS_2], [IBAN_1]) is produced only after a person has looked. The machine proposed the redaction; you prepared and reviewed it; and now, when the document leaves, it leaves under a name that can actually stand behind it.
That's the whole design philosophy in one line: let the machine do everything it's good at, and reserve for the human the one thing only a human can do — be responsible for the result.
