AP
AgentPay Dashboard

Reconnecting to wallet…

Live on Arc Testnet

On-chain spending controls
for autonomous AI agents

Set daily budgets, whitelist services, and pause anytime. Built on Arc — Circle's stablecoin-native L1 where USDC is the native gas token.

Try AI Assistant → View Contract ↗

New here? Try the chat assistant — describe what you want in plain English.

Live from Arc Testnet
—
Payments executed
—
USDC routed
—
Agent status
The problem

Autonomous agents hold keys. Keys can leak.

Today's AI agents transact on behalf of users — but without on-chain controls, one compromised key or runaway bug drains the entire wallet.

🔓

Compromised keys

A stolen agent key today means an unbounded loss — limited only by the wallet balance. Cold storage isn't an option when the agent needs to sign 24/7.

🐛

Runaway loops

A bug, a malformed prompt, or a misbehaving plan can cause an agent to loop — burning $5,000 in API calls before anyone notices.

🎯

No granular spend control

Application-level rate limits get bypassed when the code itself has the keys. The only enforceable limit is one the chain itself enforces.

📋

Auditing is painful

Finance teams need to know what each AI feature is costing, who got paid, and when — without trawling through application logs that can be tampered with.

How it works

Three on-chain rules, no off-chain trust required.

Every agentPay() call has to pass three checks before any USDC moves. The contract enforces them; the application can't bypass them.

Step 1

Register an agent

The owner calls registerAgent(agent, daily, perTx) and sets two hard caps in USDC.

dailyLimit = 5 USDC
perTxLimit = 0.10 USDC
owner = msg.sender
Step 2

Whitelist allowed services

The owner adds each receiver the agent is allowed to pay — APIs, vendors, contractors, anything.

addAllowedService(
  agent,
  openAiApiAddress
);
Step 3

Agent pays autonomously

The agent calls agentPay(to, memo) payable. The contract checks allowlist + per-tx cap + daily cap, then forwards.

✓ allowed service
✓ ≤ perTxLimit
✓ ≤ remaining daily
→ forward USDC, emit event 
   ┌──────────┐    setup       ┌──────────────────────┐
   │  Owner   │ ─────────────▶ │   AgentPay.sol       │
   │  (user)  │  register +    │  ────────────────    │
   └──────────┘  allowlist     │  • daily caps        │
                               │  • per-tx caps       │
                               │  • allowlist         │
                               │  • pause/revoke      │
                               └──────────────────────┘
                                          ▲
                                          │ agentPay(to, memo)
                                          │ (msg.value = USDC)
                                          │
                                  ┌───────────────┐
                                  │   AI Agent    │
                                  │ (autonomous)  │
                                  └───────────────┘
                                          │
                       allowlisted &      │
                       within budget?     ▼
                                  ┌───────────────┐
                                  │ Service / API │
                                  │   recipient   │
                                  └───────────────┘
Use cases

The same primitive solves two big spend problems.

🤖

AI inference cost control

Give each AI feature in your product its own agent — a chatbot, a fraud classifier, a content moderator — with their own daily budgets. A runaway prompt or a leaked key can lose at most one day's worth of credits.

  • ✓ Per-feature spend visibility for finance teams
  • ✓ Compromised key bounded to dailyLimit
  • ✓ On-chain audit trail of every API call
  • ✓ Pause an agent instantly if it misbehaves
🌍

Cross-border contractor payouts

An agency in Vietnam pays freelancers in Manila, Mumbai, and Lagos. Each freelancer's wallet is whitelisted with a per-tx cap matching their tier. Settlement is instant on Arc — versus T+1 with traditional rails.

  • ✓ Sub-second finality vs. T+1 bank wires
  • ✓ ~$0.001 of gas per transfer (vs. $25 wire fees)
  • ✓ Per-freelancer caps prevent fraud + duplicate payments
  • ✓ Programmable workflows (approval triggers, monthly limits)
Why Arc

USDC is the native gas. No ERC-20 approvals. No fee token.

Arc treats stablecoins as the base unit of the chain. That means msg.value in a payable function is already denominated in USDC — and the entire contract is ~200 lines of Solidity, not 600.

Settlement
< 1 second
Deterministic finality, ready for real-time financial workflows.
Fees
~$0.001
Per transaction, paid in USDC. Predictable dollar-denominated cost.
Stablecoin-native
USDC
No wrapped tokens, no approvals, no separate gas asset.
Tech stack

Built with

Arc Network Circle USDC Solidity 0.8.24 Hardhat ethers.js v6 Tailwind CSS EIP-6963 wallet discovery Vanilla JavaScript
25 unit tests · 2 contracts deployed · 8 on-chain transactions · MIT licensed source ↗

Try it yourself

Need a browser wallet (MetaMask, Rabby, OKX…) and Arc Testnet USDC from faucet.circle.com. The dashboard runs entirely client-side — no server, no tracking.

Wallet

—

Network

—

Balance

—

My Agents

Recent Activity