You told your client the work was human reviewed. Can you prove it?

sushil soni — Sun, 09 Aug 2026 09:59:36 +0000

Imagine this email arriving from a client:

"Before we publish - can you confirm which parts the AI drafted, and who reviewed the final version?"

If you deliver AI-assisted work, some version of this question is coming. And for most small teams, the honest answer today is a sentence, not a record:

"This was human reviewed."

Clients hear it. Editors hear it. Reviewers hear it. But in most workflows, it is still only a promise.

There is usually no small, portable record showing:

what final file was reviewed;
what AI contributed;
whether review was complete, partial, or absent;
who accepted responsibility;
whether the record still verifies later.

I built Pramaan as an open-source experiment for that narrow gap.

GitHub: https://github.com/sushilsoni-tech/pramaan

What Pramaan Is

Pramaan is a local tool for creating and verifying signed responsibility records for AI-assisted written work.

It does not try to detect AI writing.

It does not judge whether the content is true.

It does not certify legal compliance.

It does not prove every real-world action was recorded.

Instead, it creates a signed record for one finished file.

That record can say:

this is the exact final file hash;
this is what AI helped with;
this is whether human review was complete, partial, or absent;
this is who accepted responsibility;
this is the public key that signed the record;
this is whether the signed bundle still verifies later.

That smaller claim is the product.

The recipient can verify the bundle on their own machine.

For identity trust, they still need to compare the bundle's signer fingerprint against a fingerprint received through a separate trusted channel.

Why This Might Matter For Small Teams

Large organizations may eventually buy governance platforms, connect identity systems, and enforce audit workflows across every tool.

Small teams do not start there.

A small content studio, research writer, AI-assisted proposal shop, grant writer, technical writer, or responsible AI consultant often needs something much lighter:

I used AI, a human reviewed the final work, and here is the record for this specific deliverable.

That is the first use case I am testing.

The goal is not bureaucracy.

The goal is to make a human-review claim inspectable.

What It Does Not Prove

This boundary matters.

Pramaan does not prove that the underlying content is true.

It does not prove that the human review was good.

It does not prove the named reviewer is who they say they are. In the current editorial profile, reviewer identity is a producer-supplied assertion, and the signature binds the record to the producer's key, not to a separate reviewer-held key.

It does not provide trusted timestamping by itself.

It does not prove legal, regulatory, editorial, or academic compliance.

It proves something smaller:

This signed record has not changed, it refers to this final file, and it satisfies or fails the declared checks.

Try The Samples

The repo includes one PASS sample and one FAIL sample:

git clone https://github.com/sushilsoni-tech/pramaan.git
cd pramaan
python -m pip install .
pramaan verify samples/editorial-pass
pramaan verify samples/editorial-fail-missing-reviewer

The PASS sample - a complete declared review record:

$ pramaan verify samples/editorial-pass

Pramaan signed-file integrity: PASS
Pramaan overall verification:  PASS

Editorial checks: satisfied=6, not_satisfied=0, unverifiable=1
[EDITORIAL satisfied]    review.substantive_recorded
[EDITORIAL satisfied]    responsibility.named
[EDITORIAL satisfied]    content.hash_matches
[EDITORIAL unverifiable] reviewer.identity_bound

[WARN] UNPINNED_SIGNER: signature is valid, but the signing key was
       not checked against an independently obtained fingerprint
[OK]   VERIFIED: record is internally consistent and satisfies the
       declared policy

The FAIL sample - signed files intact, but the review claim doesn't hold:

$ pramaan verify samples/editorial-fail-missing-reviewer

Pramaan signed-file integrity: PASS
Pramaan overall verification:  FAIL

Editorial checks: satisfied=2, not_satisfied=2, unverifiable=3
[EDITORIAL not_satisfied] review.substantive_recorded:
    No substantive human review is claimed for this item.
[EDITORIAL not_satisfied] responsibility.named:
    No responsible person or entity in the signed record.
[EDITORIAL satisfied]     content.hash_matches
[EDITORIAL satisfied]     record.integrity

[ERROR] EDITORIAL_CHECKS_NOT_SATISFIED

Notice the second result: integrity PASS, verification FAIL. The cryptography is intact - nothing was tampered with - but the declared human review is missing, so the record honestly fails. That is the core design choice: Pramaan is not a badge generator. It is allowed to tell you that a signed record does not satisfy its own claims.

Who I Am Looking To Learn From

This may be useful if you already make a public or client-facing human-review promise:

AI-assisted content studios;
SEO and editorial agencies;
freelance researchers or writers;
grant and proposal writers;
technical writers;
responsible AI consultants;
small teams sending AI-assisted written deliverables to someone else.

If nobody ever asks you to explain or evidence human review, Pramaan may be unnecessary.

If your clients already ask what AI contributed, who reviewed the work, and who is accountable, Pramaan may be a useful primitive.

The Open Question

The question is not whether AI-assisted work will continue. It will.

The question is whether "human reviewed" stays an unverifiable phrase - or becomes something a second person can inspect.

Here's my honest stance: within a few years, sending a client AI-assisted work without a verifiable review record will feel like sending an invoice without an ABN. Not illegal. Just unprofessional.

Maybe I'm wrong about that. Tell me.

If you've ever been asked to prove human review - or dodged the question - I'd genuinely like to hear how you handled it. Comments open.

Want to poke at the tool itself? The repo includes a PASS sample and a FAIL sample you can verify in two minutes:
https://github.com/sushilsoni-tech/pramaan

And if you have deeper structural feedback, there's a dedicated issue for it:
https://github.com/sushilsoni-tech/pramaan/issues/3