ACTEX Pay
Agents buy. Every transaction checks out.
Policy enforces the rules. Recovery handles the rest. Clean records prove what happened — export and verify offline.
Delegated checkout
Policy caught the exception and closed the loop.
Merchant allowlist enforced, recovery replay captured, and the final audit bundle is ready.
Outcome PASS
Mandate accepted Budget, allowlist, and liability boundary compiled.
Merchant exception recovered ACTEX blocked the out-of-policy path and retried within bounds.
Post-purchase case resolved Refund status normalized, evidence attached, and settlement finalized.
How it works
Three steps. No support chaos.
Create a contract
Define budget limits, merchant allowlists, and liability boundaries. The agent operates within these guardrails — not outside them.
Verify and recover
When checkout stalls or policy violations occur, ACTEX catches the exception and retries within bounds. No human needed.
Export the receipt
Every transaction produces a signed, offline-verifiable audit trail. Hand it to Security, Finance, or Audit without replaying logs.
Why ACTEX Pay
The ops layer between "the agent bought something" and "we can prove it was OK."
Governance and control
Contracts enforce spending limits, merchant allowlists, and liability boundaries before the agent touches a checkout. Policy violations are caught, not discovered later.
Exception recovery
Stuck checkouts recover automatically. Returns, refunds, and disputes resolve end-to-end within rights windows. No support tickets, no manual escalation.
Portable proof
Receipts and Casefiles are signed, exportable, and verifiable offline. When Security or Finance asks "what happened?" — the answer is a file, not a Slack thread.
Today
Checkout turns into support work
Your AI agent tries to buy cloud credits. The checkout gets stuck, an exception fires, nobody knows the status, and a human has to untangle it.
With ACTEX Pay
Recovery happens before support gets involved
ACTEX catches the stuck checkout, recovers automatically, and resolves the exception without human escalation. A clean record proves what happened — export and verify offline.
Control & Governance
You set the rules. The agent follows them.
Every agent purchase runs through policy rails you define — spend limits, merchant allowlists, and escalation triggers. Nothing executes outside the boundaries you set.
Approval gates
Human-in-the-loop before any purchase. Choose autonomy modes — Suggest (human approves every action), Delegate (agent acts within bounds, escalates edge cases), or Autopilot (full autonomy inside policy).
Spend policy bounds
Per-transaction limits, recurring cycle caps (daily/weekly/monthly), currency constraints, and category restrictions — compiled into enforceable mandate rail policies before the agent can act.
Escalation rules
Step-up thresholds pause the agent and ask a human when a transaction exceeds a configured amount. Out-of-policy merchants, unknown categories, and geo-restrictions trigger automatic holds.
Human override points
Cancel, modify, or dispute any transaction at any stage. Override autonomy settings in real time. Every override is recorded in the audit trail alongside the original policy.
Under the hood
Every handoff becomes a verifiable record
From checkout attempt to clean audit trail. Agents coordinate, verification gates lock state, and receipt evidence exits as a reusable Casefile — a portable, offline-verifiable proof bundle.
- Listing
- Contract
- Offer
- Result
- Receipt
- Casefile
Use cases
Three deal archetypes, one recovery pipeline.
Delegated checkout
Agent buys under constrained authority, resolves exceptions, and exports receipt + Casefile proof for delayed owner review.
B2B procurement
Agent sources from multiple sellers, compares offers, and settles with verification gates and escrow holds.
Compliance audit replay
Regulator or auditor verifies the full transaction chain offline from an exported Casefile, no platform access needed.
How is this different?
Stripe, Shopify, and agent frameworks each solve a piece. ACTEX Pay fills the gap between them.
Stripe + webhooks
Stripe moves money. But when an agent checkout stalls mid-flow, there is no built-in recovery loop, no policy enforcement, and no portable proof that the transaction resolved. ACTEX sits after the payment rail and adds the operational layer: recovery, governance, and audit.
Shopify + apps
Shopify runs storefronts. Agents acting on behalf of buyers still need constrained authority (mandate contracts), exception handling when things go wrong, and exportable records that survive outside the platform. ACTEX provides those pieces without replacing the storefront.
Agent frameworks
LangChain, CrewAI, and similar frameworks orchestrate agent logic. They don't define how agents authenticate to commerce APIs (ACTEX uses Ed25519 request-bound signatures), how post-purchase disputes resolve, or how audit trails export as offline-verifiable Casefiles. ACTEX Pay is the commerce ops layer those frameworks call into.
Complementary, not competitive. Use Stripe for payments, Shopify for storefronts, your agent framework for orchestration. Use ACTEX Pay for what happens around and after the transaction: agent-native auth, portable casefiles, post-purchase governance, and verification infrastructure.
Get started
Pick a path
Evaluate
See ACTEX Pay in action with a guided walkthrough.
Watch DemoBuild
Create your first contract in 5 minutes.
QuickstartVerify
Upload and verify a casefile proof.
Casefile