Paymove is the settlement layer for agentic commerce on Visa’s protocol. Humanos slots into the settlement path as the dedicated authorization stack — a 3rd-party API that verifies every high-value spend against a human-signed mandate before it settles, and emits a portable, on-chain-anchored receipt either party can check.
Visa’s agentic commerce protocol gives autonomous agents a real rail to transact on. Paymove settles agent-initiated transactions on that rail — provisioning wallets, holding balances, and moving money the moment an agent acts.
Humanos plugs into Paymove’s settlement path as the dedicated authorization stack — a 3rd-party API that makes authorization a runtime primitive instead of internal wallet logic. Every high-value spend is verified against a human-signed mandate before it settles, and every settled payment carries an immutable, portable, on-chain-anchored receipt.
Visa’s protocol lets an agent transact on a real rail, and Paymove gives it a wallet to spend from. But autonomous spend still depends on the agent’s own logic to decide what’s allowed. Limits, approvals, and “did the human actually agree to this” live inside one party’s code and database — checked by the same system that moves the money.
Paymove can settle a transfer on the Visa rail in seconds. Whether a human actually authorized that specific spend — this amount, to this counterparty — lives in the agent’s own logic, and was never designed to answer, at the moment money moves, “is this exact payment authorized?”
An enterprise diligence team or a Visa-scale partner reconstructs what the agent did from one party’s logs — never that any given spend was actually allowed. Every new partner, every regulator restarts the work. Authorization stays internal state; nothing portable, nothing both sides can check.
Before any spend that crosses a defined limit settles on the Visa rail, Paymove’s wallet calls humanos.verify(). Signature, counterparty (IBAN), amount, validity, and network membership are checked in real time against a human-signed mandate, and a deterministic answer is returned that Paymove attaches to a portable, on-chain-anchored receipt.
Within limit, to an allowed IBAN, within validity. Paymove settles the spend on the Visa rail. A Receipt is attached to the transaction — portable, anchored on-chain, verifiable by either party without trusting the other’s database.
Over the limit, unknown IBAN, expired, or revoked. Humanos collects fresh human approval in real time (OTP by SMS, link by email), updates the mandate, and resumes once authorization is valid. The agent never silently spends or guesses.
Five stages in chronological order. The animation on the right walks through one agent payment end-to-end — authorized by the Paymove account owner, verified by Humanos in the settlement path, and settled on the Visa rail only after a deterministic yes/no.
The Paymove account owner defines a “make a payment” action and authorizes its limits — a maximum amount and a list of allowed IBANs. Humanos issues a machine-verifiable mandate — signed once, reusable across every payment the agent makes.
The Paymove agent wallet assembles the proposed payment — amount and destination IBAN. It presents the credential ID of the user-signed mandate and requests a verifiable presentation built on W3C VC 2.0, attached as x-humanos-mandate.
Before the payment settles, Paymove calls humanos.verify() directly against the mandate. Signature, counterparty (IBAN), amount, validity, and network membership are checked in 184 ms — deterministic, no LLM in the path.
Authorized → Paymove settles the payment on the Visa rail and writes the receipt. Not authorized → the agent doesn’t fail silently or guess. For Paymove’s out-of-scope attempts (an €18,000 transfer beyond the limit), Humanos blocks before settlement and triggers a real-time step-up.
Every settled payment emits a cryptographic Receipt — the mandate hash anchored on-chain, attached to the transaction, portable forever. Both parties, partners, and regulators verify the Receipt directly against Humanos and the chain; nothing reconstructs trails from Paymove’s internal logs.
Nothing settles on assumption. The verify call is non-optional and inline — in the settlement path, before money moves on the Visa rail, not after the agent has already spent.
The agent stays probabilistic where it matters (reasoning, context). The spend-or-not boundary becomes a yes/no — no LLM in the verification path.
Every settled payment emits a portable Receipt, with the mandate hash anchored on-chain. Both parties verify directly; they don’t reconstruct from one side’s database.
Over the limit or an unknown IBAN? Humanos collects approval (OTP by SMS, link by email, KYC), updates the mandate, and resumes settlement once authorization is valid. No silent spends.
Issue once; verify anywhere. The mandate authorizes spend to a specific IBAN and amount, so the boundary travels with the transaction — independent of which system executes it.
The mandate authorizes this amount, to this counterparty — not a coarse spending category. The boundary is the IBAN and the limit, cryptographically signed by a human.
Issue once. Verify anywhere — counterparties, partners, regulators, and the chain.
External parties check authority against Humanos and the on-chain hash — without trusting Paymove’s database.
No new authorization logic per partner. The integration is the verify() call.
The more systems verify against Humanos, the more valuable every mandate becomes.
Agents pay suppliers and vendors. Every transfer scoped to an approved IBAN and amount, authorized at settlement, carrying a portable receipt.
Agents top up balances and pay recurring invoices. Humanos verifies each charge sits inside the mandate — within the limit, to an allowed IBAN — before it settles.
Payouts, refunds, cross-border transfers. The agent proposes; Humanos verifies authority and emits a Receipt the counterparty can verify independently, on-chain.
The Paymove agent settles on behalf of a human account owner across every counterparty it pays. Every payment carries the owner’s mandate — verifiable by every party it touches.
Human authorizes a “make a payment” action — amount limit and allowed IBANs. Humanos issues a machine-verifiable mandate, reusable across every payment.
Paymove runs humanos.verify() in the settlement path. Deterministic yes / no.
Over the limit or an unknown IBAN? Request step-up authorization from the human owner in real time — API, SMS, or email.
Cryptographic Receipt per payment, mandate hash anchored on-chain. Auditable forever. Verifiable by anyone.
At that moment, authorization must be verified, the decision must be deterministic, and the outcome must be provable. Everything else follows.
Plugged into Paymove’s wallet as the dedicated authorization stack — every high-value spend inherits it by default.
The verification path is deterministic. No LLM in the verify call.
Auditable, immutable, portable forever — the mandate hash anchored on-chain, independently verifiable.
