The control plane for agentic payments

Your AI agents will spend money.
Make sure it goes where it should.

AI Payment Guard sits between your agents and any payment rail. Every transaction is evaluated against your rules, held for human review when risk is high, and recorded in an inviolable audit trail. Three lines of integration, zero room for runaway spend.

Append-only audit chainHMAC-signed webhooksIdempotent by design
POST /payment-intents
live
€7,500.00
Local Supplier SARL
REQUIRES HUMAN
Authorizationops-agent · pg_live_b97306…
Idempotencydedup window honored
Policy matchamount_gte_500000_EUR → require human
Risk score58 / 100 (medium)
Audit event #149hash 9af1c3…
The problem

Agents that can act can also drain your treasury.

Prompt injection, runaway loops, mis-calibrated tools, hallucinated invoices. The same autonomy that makes agents useful makes them financially dangerous. Built-in guardrails inside the agent are too fragile; bank-side limits are too coarse. You need a control layer between them.

  • Built-in guardrails fail silently
    Agents do what their context tells them. A poisoned tool description or a successful jailbreak undoes any internal limit.
  • Bank limits are too coarse
    A €100k/month cap on a corporate card doesn't help when an agent burns €40k on the wrong vendor in 4 minutes.
  • Compliance can't audit a black box
    If you can't show every decision, who approved it, and when, your CFO will refuse to deploy autonomous agents to production.
How it works

One control plane, every payment intent.

Your agents never touch the rail directly. They submit intents to AI Payment Guard, which evaluates rules, requests human approval when needed, and only then unlocks execution.

1

Submit

Your agent posts a payment intent over HTTPS with a Bearer key and an Idempotency-Key. The API responds in under 100 ms.

2

Evaluate

A pure policy engine walks your rules in priority order: REJECT wins, then human review, then auto-approve. Default is fail-safe.

3

Decide

The decision is returned synchronously. Approvals and rejections are signed, logged in an append-only chain, and notified via webhook.

Three lines that change everything

From unlimited spending to fully governed in one afternoon.

The official Node.js SDK ships with auto-generated idempotency keys, exponential retries on transient errors and a typed webhook verifier. Your agent code stays clean — the control logic lives where it should: server-side.

View the SDK reference →
agent.ts
import { PaymentGuard } from "@payment-guard/node";

const guard = new PaymentGuard({ apiKey: process.env.PG_KEY! });

// Before every payment, ask permission.
const intent = await guard.paymentIntents.submit({
  amount_minor: 24_900,
  currency: "EUR",
  beneficiary: { name: "AWS", account_identifier: "DE12500105170648489890" },
  category: "infrastructure",
  memo: "Monthly invoice",
});

if (intent.decision === "APPROVED") {
  await guard.paymentIntents.execute(intent.id);   //  ✅
} else if (intent.decision === "REJECTED") {
  log("blocked by policy", intent.decisionReason); //  🚫
} else {
  // Wait for the webhook — a human will decide.   //  ⏸
}
Features

The full guardrail stack.

Every primitive a CFO, a Head of Risk and an integration engineer would ask for — built in, not bolted on.

Configurable policy engine

Six rule types out of the box: amount thresholds, daily caps, beneficiary whitelists, category blocks, time windows and per-agent scopes. Combine them with priorities.

Hash-chained audit trail

Every event is appended with a sha-256 hash linked to the previous one. Append-only enforced by a database trigger — even a rogue admin cannot tamper.

Human approval workflow

Pending payments land in a queue with risk scores and beneficiary history. Approvers decide with one click; rejections require a reason.

Risk scoring

A 0–100 score per intent, computed from beneficiary history, agent patterns, time of day, missing memo and sensitive categories. Explainable factors, not a black box.

Webhooks & SDK

HMAC-SHA256 signed deliveries with retries. Official Node.js SDK with typed errors, auto-idempotency and a constant-time signature verifier.

Multi-tenant from day one

Strict organization isolation in every query. Role-based access — Owner, Admin, Approver, Viewer — plus separation of duties between humans and agents.

Use cases

Wherever an agent can move money.

Rail-agnostic by design. Whatever sits behind your executor — Stripe Treasury, open banking, an MPC wallet, a virtual card — the control logic doesn't change.

Operations

SaaS & cloud spend

Cap how much your agents top up on AWS, OpenAI, or any per-call API. The use case AI-native teams care about most.

Finance

B2B fiat outbound

Vendor invoices, payroll, supplier payments via SEPA, ACH or wire. Apply per-beneficiary rules and human review above thresholds.

Web3

Crypto treasury

Plug into Fireblocks or any MPC custody. Policy thresholds become signing thresholds. Stablecoin payouts, rebalancing, smart-contract calls.

Platforms

Marketplace payouts

Seller disbursements, refunds, affiliate commissions, insurance claims. Apply velocity caps and anomaly checks at scale.

Automation

Procurement agents

Inventory restocking, ad-buying agents, automated negotiation. Approve below seuil, escalate above — with full traceability.

Support

Customer-facing AI

Refund and goodwill agents that can compensate up to a limit, escalate beyond. Bound the blast radius of what your AI can give away.

Built for compliance

The kind of trail your audit committee will actually accept.

Tamper-evident

Append-only at the database level

Every audit event lives in a table where UPDATE and DELETE are blocked by a PostgreSQL trigger. Even with raw SQL access, no one can rewrite history.

Cryptographic

Signed hash chain

Each event references the sha-256 of the previous one. Verify the entire chain on demand — a single broken link surfaces immediately.

Operationally safe

Idempotent by contract

Every payment intent submission requires an Idempotency-Key. Replays are de-duplicated server-side; double payments are structurally impossible.

Governance

Separation of duties

Agents can submit and execute. Humans approve and audit. The two identities are distinct: an agent can never approve its own intent.

Give your agents power.
Keep the keys to the safe.

Try the full-stack demo locally in 60 seconds, or book a call to discuss your deployment.