Alejandro

AI-generated text is no longer distinguishable from human text. That's not a hot
take, it's a measurable fact at this point, and it quietly breaks a lot of the
trust assumptions the internet runs on — messaging, marketplaces, escrow, forums.
If you can no longer tell what was written by a bot, the obvious next question
is: can you tell how it was written?

That's the premise behind PoHI (Proof of Human Intent), a protocol I've been
building on my own: instead of analyzing text content, it measures the physical
rhythm of typing — dwell time, flight time between keys, the skew of your pauses,
how you correct mistakes — and proves, via a zero-knowledge SNARK, that the
resulting score clears a threshold, without ever revealing the raw keystroke data.

The stack, briefly

  • @pohi-protocol/core-math — the reference math engine implementing the behavioral equations (skewness, cognitive-latency ratio, error-recalibration variance). 74 unit tests.
  • circuits/ — a Circom circuit compiling to Groth16 over BN254, ~12,500 constraints, with a real multi-party trusted-setup ceremony tool. 21 tests checking it agrees numerically with the reference engine and that the constraint system actually binds every signal — regression tests for soundness bugs I found and fixed in my own circuit.
  • packages/sdk-web — the browser-side capture SDK.
  • experiments/ — an adversarial evaluation harness with six attacker models, from "constant-delay macro" up to "an attacker with full knowledge of the scoring function trying to fake the rhythm."

Everything is open: https://github.com/ProjectOne2020/pohi-protocol-poc

The honest part

I'm not here to tell you this is unbreakable. It probably isn't, at least not yet.
A zk-SNARK proves you know a witness satisfying the relation — it does not
prove that witness came from an actual human hand. That's a real, documented gap
(I wrote it up in the threat model instead of hiding it — see
docs/THREAT_MODEL.md §5),
and I pre-registered the exact condition that would falsify the whole approach
before collecting a single data point: if a cheap, offline-generated fake
typing pattern gets accepted more than 50% of the time, software-only PoHI
doesn't hold up, and hardware attestation becomes mandatory instead of optional.

To test that, I need real human typing data — which is the actual ask here.

Can you give me 5 minutes?

👉 https://pohi-protocol-poc.vercel.app

You type a few short prompts, that's it. Available in English and Spanish. What
gets recorded is only keystroke press/release timestamps in milliseconds and
whether a key was Backspace — never the text itself. That's not just a privacy
promise: the database schema itself has a constraint that rejects any record
containing character data, so it holds even if someone tampers with the client.
You can check that directly in
experiments/schema.sql.

If you're more interested in poking at the code than typing, I'd take that too —
issues, PRs, "your fixed-point division is still wrong here" comments, all
welcome. Especially if you can break the scoring.

Repo: https://github.com/ProjectOne2020/pohi-protocol-poc
LinkedIn: https://www.linkedin.com/in/alejandro-guti%C3%A9rrez-9a0318107/