Revvyn decides before money moves. Your rail (SEPA, card, stablecoin) executes. Revvyn never holds or moves funds.
Six checks, run in sequence — agent standing, routing, policy, risk, rail hand-off and audit — decide whether an agent's payment is allowed, blocked or escalated. Deterministic, and recorded.Every decision is reasoned and replayable; verdicts from Revvyn's verifiable-verdict API are cryptographically signed and sealed into an append-only, hash-chained record you can re-run chain verification on in the console.
A payment intent comes in one side; a governed verdict comes out the other. But the six aren't stages in a script, they're agents, each working its own domain, and one agent's finding changes what the next one decides.
This is the part most systems don't have: the checks aren't a mere checklist — each consumes the signals the earlier ones produced, and that is recorded in the append-only, hash-chained audit log, so you can see which earlier signals each check used.
Every payment intent sent to Revvyn gets one verdict before settlement, and the reasoning behind it is captured in full, so a regulator, a partner, or you can ask why and get a real answer.
Agent in good standing, policy satisfied, risk within bounds. The payment proceeds to its rail.
A sanctions hit (OFAC crypto-wallet screen or a restricted jurisdiction), an exposure ceiling, or a policy breach — the reason is logged, and no money leaves.
Borderline trust, or a payment above the review threshold. It's held for human review; a reviewer approves or rejects (single reviewer today; two-person sign-off is not yet enforced), and the escalation and step-up loop are recorded end to end.
Every decision on your payments, visible and verifiable, running on real engine data. Numbers are early because the network is early; every figure is the genuine current value.
Your payments governed, allowed, blocked, and escalated, with your live decision feed.
Re-open any of your past decisions and step through the signals and reasoning that produced it.
See your payment move through the six checks, stage by stage, in real time.
Integrate directly: submit a payment, get one verdict, pull the append-only, hash-chained audit trail.
A governance layer earns trust with deterministic, explainable decisions first. So some capabilities beyond the decision engine are built to varying degrees — some tested, some still dormant — and are deliberately not live yet. Each is labelled below with exactly where it stands.
Agents consult on corridor posture today with a one-way, static response; multi-round negotiation is modelled and unit-tested but is not produced by any agent yet.
Inter-agent contradictions are detected automatically and surfaced for human resolution; automated evidence-weighted resolution is built and tested but not yet wired to the payment path.
Decisions and events are written to memory and looked up on later events.
The escalation contract is built and active in code, with completion tested against a reference (test) issuer in our test suite. Plugging in a real bank's step-up is an integration, not a build.
We turned our most advanced capabilities off for launch on purpose, because determinism and auditability come before autonomy when the thing being governed is money. It's in the codebase. You can review it.
Revvyn is pre-production: the governance engine is real and usable today. Production rail integrations and formal certifications are in progress, not complete. We won't claim otherwise.
No slides, no canned demo. Run a governed decision through Revvyn's live pipeline right now — a scripted test scenario; no money moves — and watch each agent decide, with a chain-verified trail.
Revvyn is in invite-only private preview. The site and this live proof are open to view; access is granted by request. Prefer a guided start? Request access →
Signed mandate credentials presented to Revvyn are verified against published keys. Sign one yourself with a key that is not Revvyn's, claim to be Revvyn's issuer, and submit it. Revvyn verifies the signature against Revvyn's real published keys, catches the forgery in-line, and escalates it for a human to review. It is never silently approved.
Where this goes: every agentic transaction, governed, with a decision that's explainable, recorded, and yours to re-run chain verification on in the console.
Today that's payments through a six-stage pipeline. The direction is the standard the rest of the stack can assume.