ArcSLA is a marketplace where providers put USDC on the line for every request. Miss the deadline — lose the stake. No court, no dispute process, no waiting. No arbiter. No middleman.
When a developer — or an autonomous AI agent — pays an API provider, there is no guarantee the provider will respond, respond on time, or respond at all.
The usual answer is a contract, a support ticket, a dispute process — slow, human, and unenforceable across borders or between machines.
Machine-to-machine commerce needs a guarantee that is economic and automatic — one that settles in seconds, with no one to call.
Payment is sent up-front and trust is assumed — the provider holds all the leverage.
A missed deadline means a support ticket, a chargeback, or simply a loss.
Reputation lives in private dashboards no other system can verify.
An AI agent has no way to assess or enforce a provider's reliability on its own.
Every call follows the same on-chain lifecycle. The smart contract holds the money and enforces the terms — from the moment a call opens to the moment it settles.
A provider stakes USDC as collateral and publicly commits to SLA terms — price, response window, and slash percentage.
A caller pays the per-call price. The USDC is escrowed inside the contract — not sent to the provider — and the SLA countdown begins.
The provider delivers off-chain, then submits an EIP-712 signed receipt on-chain — readable, structured, verifiable.
On time, the escrow releases to the provider. Late, anyone can trigger a timeout — and the slash fires automatically.
Every honored call and every slash is counted on-chain, feeding a public reputation score any system can read.
The common case. The provider responds within the committed window and gets paid instantly.
No response, no excuse. The caller gets their money back plus a cut of the provider's stake. The contract handles it.
claimTimeout() — no privileged role needed.An SLA is only as strong as its consequence. On ArcSLA, a provider's commitment is backed by real collateral — and breaking it has an immediate, on-chain cost.
When a provider stakes USDC, they expose a defined percentage of it. Miss the deadline, and that slice is transferred to the caller as compensation. The contract computes and executes it — there is no appeal, and no one to appeal to.
The result: spam and negligence become unprofitable, while reliable providers keep their full stake working for them.
Every provider carries a reputation score derived entirely from their on-chain history of honored calls and slashes. It is not a private rating — it is public state, computed by the contract.
The score uses a Bayesian formula, so a provider with little history sits near a neutral midpoint rather than a misleading 0% or 100%:
Because it lives on-chain, an auto-router or an AI agent can read it directly and pick a reliable provider with no off-chain lookup — trust becomes programmable.
Multiple ways to pay, a verifiable identity layer, and machine-readable trust — all enforced by the same contracts.
Caller payments are held by the contract until the SLA resolves — never by a middleman.
Missed deadlines trigger an immediate, contract-computed penalty. No arbiter, no delay.
Providers sign structured, human-readable receipts — verifiable on-chain, no opaque hex.
A public 0–100 score, computed on-chain, that any contract or agent can read directly.
Providers bind a verifiable AgentIdentity NFT to their registration for portable identity.
Agents pay through a live x402 facilitator — EIP-3009 settlement on Arc, no gas for the payer.
Pay from Ethereum, Base or Polygon — Circle bridges the USDC and Arc enforces the SLA.
Predictable fees and sub-second finality make autonomous, per-call commerce practical.
A full Foundry test suite covers registration, calls, receipts, timeouts and slashing.
ArcSLA is plain EVM. If you know ethers.js, you already know how to call it. Approve USDC, open a call, and you are on-chain — the contract handles escrow, receipts and enforcement.
The full Solidity source, the Foundry test suite and deployment scripts are open on GitHub.
ArcSLA is built on Arc Testnet — Circle's stablecoin-native L1. Three properties make it the natural home for machine-to-machine payments.
USDC is the native gas token and the settlement currency. No second asset to hold, bridge or manage — for users or for agents.
Transaction costs are stable and roughly a cent — not tied to a volatile coin. Essential when an agent makes thousands of micro-payments.
Calls confirm in under a second, so an SLA countdown — and its enforcement — operate on a timescale agents can actually rely on.
callId and
responseHash — in a readable format rather than an opaque hex blob.
The contract verifies that signature on-chain before releasing escrow.
submitReceipt(). At that point the call can only be resolved through
a timeout, which refunds the caller and slashes the provider.
claimTimeout() is permissionless once the deadline has
passed — there is no privileged role. In practice the caller triggers it, since
they receive the refund and the slash compensation.
(good + 2) / (total + 3) × 100. A new
provider starts near 66 — neither trusted nor distrusted. Each honored call
raises the score; each slash lowers it. The value is stored on-chain and readable
by any contract.
Register a provider, open a paid call, watch a slash fire — all with test USDC, live on Arc Testnet.
Launch the app →