Proof you can
verify,
not trust.
It turns the real screen of a live mobile app into a cryptographically verifiable claim. A local vision-language agent reads the UI and seals it into a proof-bundle with a device-bound signature and freshness proof — and raw data never leaves the device.
Watch a proof-bundle seal itself.
A local agent reads a live banking app and seals a single verifiable claim — balance > $10,000 — with real ECDSA P-256 + SHA-256, right here in your browser. The exact balance never leaves the phone until a dispute is opened.
- 1Device attestation
- 2Task + freshness challenge
- 3Agent reads UI · seal bundle
- 4Anchor to registry
- 5What leaves the device
- 6Independent verification
- 7Attack · tamper
- 8Attack · replay
- 9Dispute · open commitment
The internet runs on apps.
Almost none of it is verifiable.
As everything scales, synthetic and processed data blends with authentic sources — usually with no clear provenance back to the origin. Trust is assumed; it is rarely proven.
Oracles relay APIs
Most oracles just paraphrase an API response — not what the user actually sees in the app. Along the way data is cropped, reworded, mixed with noise and reposted without provenance.
Trust ≠ verification
Cryptography was built for continuous verification, yet in practice it protects the infrastructure layer — not the consumer-facing state people rely on every day.
Capture provable state
We move from blindly relaying data to capturing a provable state transition — sealed at the UI of a real device, signed, time-bound, and independently checkable.
Trust comes from verifiable state transitions — not from the reputation of an operator.
From real execution to sealed proof.
Raw app detail never leaves the device. Only verified proof-bundles cross the boundary.
Task format
A node receives a task definition — “verify state X in app Y”. The protocol only defines formats; it never touches execution or results.
› task: { app: 'Revolut', assert: 'balance.gt', tier: 'anchored' }Watch a bundle seal in real time.
The local agent reads the UI, extracts a typed claim, signs it with the device key, binds a freshness watermark and selective reveal — then seals an independently verifiable proof-bundle. Raw data never leaves the device.
The network is running.
A live, node-powered mesh of devices sealing proof-bundles right now. State persists — these counters never reset.
Pick your depth of proof.
Different scenarios need different guarantees. The buyer chooses a tier to match their risk model — verification is always independent, trust is never assumed by default.
Liveness
A lightweight liveness check — proof a real run happened on a real device.
- ✓ Liveness guarantee
- ✓ Execution metadata
- ✓ Run watermark
Signed
Device-bound signature plus authenticity proofs. The default for on-chain consumption.
- ✓ Everything in Liveness
- ✓ Device-bound signature
- ✓ Authenticity proofs
- ✓ Freshness binding
Anchored
Anchored to an open attestation registry — immutable timestamps and full composability.
- ✓ Everything in Signed
- ✓ Registry anchoring
- ✓ Immutable timestamp
- ✓ Composable proof
Prove the fact. Hide the number.
Built-in selective disclosure lets a node prove “balance exceeds $10,000” without ever exposing the exact figure. Full integrity, full privacy, fully checkable.
// stays inside the device — isolated
reveals: predicate only
value: withheld · zero-knowledge
verify(bundle): true
The value is sealed in an elliptic-curve commitment.
The protocol's selective reveal rides on a Pedersen commitment over P-256 — perfectly hiding, binding and additively homomorphic — paired with a zero-knowledge Σ-proof that the operator knows the opening. The exact value never leaves the device; on dispute the opening is checked with pure curve arithmetic.
Where provable state matters.
Anywhere trust is currently assumed about what an app shows — Veriphy replaces the assumption with a proof.
DeFi-adjacent oracles
Verifiable signals only visible inside an app — retail prices, availability, configs — turned into provable claims.
Reserves & balances
After FTX, transparency isn't a slogan. On-device checks emit a claim when a balance clears a threshold — exact sums stay hidden.
Account ownership
Control is usually guessed via OAuth. Here it's a claim, backed by crypto. Credentials are never revealed.
AI training provenance
Quality tracks origin. Veriphy captures the run as it happens — bound to device and time, attached at the start, not backfilled.
Compliance & audit
Screenshots aren't enough. A verifiable bundle shows when, where, what and how — built for rigorous independent review.
Credit-relevant claims
Narrow assertions without full disclosure: “account age over threshold”, “no recent overdrafts”, “status in good standing”.
Market & supply signals
Listings, prices, stock indicators — captured as verifiable claims without depending on API access.
What's inside a proof-bundle.
Verification doesn't depend on trusting Veriphy — it rests on the artifacts below, each independently checkable.
Device attestation
Each device mints a cryptographic identity on the spot; its public key is registered and proofs are signed locally. Standing accrues over time.
Freshness proof
A watermark binds run-instant, seen-condition and captured result — preventing replay and pinning the exact moment the data was valid.
Authenticity proofs
When it matters, prove the data source and server authenticity, hide sensitive parts, and stay independently checkable — no special server cooperation.
Anchoring
Optionally bind the bundle to an open attestation registry for immutable timestamps, public verifiability and composability.
App-layer capture
Data is read from the same UI a real user sees — not an API.
Data isolation
Raw data never leaves the device; only proof-bundles do.
Independent verification
No trust in the operator required.
Flexible proof depth
Tiers match your risk model.
Privacy by default
Selective reveal instead of a full data dump.
Stop trusting.
Start verifying.
Run a node, generate proof-bundles, and earn standing on a network where truth is cryptographic — not reputational.