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.
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
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.