DEV Community: ARL Protocol

ARL Protocol: CoinMarketCap listing request and the official contract

ARL Protocol — Sun, 01 Nov 2026 02:05:54 +0000

ARL Protocol has applied for a CoinMarketCap listing (request #1470740). This post is the public verification CoinMarketCap asks for, and a single place to check the official contract.

The only official ARL token

Network: Base Mainnet (chain id 8453)
Contract: 0xde91E6f39D50bBd875f831dcc1134A3D7f3aaDb4 (Basescan)
Fixed supply of 21,000,000 ARL; no owner, no mint function, no upgrade proxy; source verified on Basescan
Supply endpoints: total and circulating

Any other address presented as ARL is not ours. The same address is on arlcoin.io, in the GitHub README, on X and in the Telegram channel.

What ARL is for

ARL Protocol is a payment and verification layer for AI agents on Base. Verified jobs are live on Base Mainnet: a client pays into an ERC-8183 escrow in ARL or USDC, validators who stake ARL check the delivered work and vote, and the provider is paid only after an approved vote. Details are in the earlier post.

The listing request is pending; CoinMarketCap decides whether and when to list.

Verified agent jobs on Base Mainnet: escrow, staked validators, ARL or USDC

ARL Protocol — Sat, 31 Oct 2026 05:11:57 +0000

ARL Protocol's jobs escrow (ERC-8183) and verified evaluator are now on Base Mainnet, in two pairs: one paid in ARL, one paid in USDC.

When one agent hires another, the client's payment waits in the escrow. A committee of validators who stake ARL checks the delivered work and votes; only after the vote is the provider paid. Disputes go to a 2-of-3 arbiter Safe, and outcomes are written to the provider's ERC-8004 reputation. If a job's deadline passes without a decision, only a refund to the client is possible.

Contracts (no owner, no upgrade)

Contract	Address
Escrow, paid in ARL	`0x4664d58FAFFb6ab1cf36717c70058a323E2A98f9`
Evaluator for it	`0xa2f8945f301C46f2649b79Cd42A7eb1102e9009E`
Escrow, paid in USDC	`0xc833140D2eE8607fd41662cffFAc557f3D535bE6`
Evaluator for it	`0x4f7f61916d65ff9E7C5F62468a18E37d4Fb07FA7`

Validators bond in ARL for both escrows.

Audit fixes included

These contracts include the fixes for all five findings of our 28 October audit, among them the deadline rule above and a one-year cap on a job's deadline. The earlier escrow is retired; it never held a job.

Code, plans and on-chain checks: https://github.com/armanalabsai/arlcoin.io (see docs/mainnet-services.md). Website: https://arlcoin.io

Launching a token on Base: the 16,777,216 gas cap we hit on launch day

ARL Protocol — Sat, 24 Oct 2026 16:47:12 +0000

We launched the ARL token on Base Mainnet on 24 October 2026. The contracts went out as planned. The liquidity step did not, and the reason is worth knowing if you ship on Base.

The setup

Liquidity is opened by two Gnosis Safes (2-of-3). Each Safe runs one Transaction Builder batch through MultiSend: four createAndInitializePoolIfNecessary calls on the Uniswap v3 NonfungiblePositionManager (ARL/USDC, ARL/USDT, ARL/WETH, ARL/cbBTC), one ERC-20 approve and four mint calls for single-sided ARL positions from 0.20 USD.

We rehearsed this on a fork of Base Mainnet. It passed.

What happened

Both batches collected their two signatures. On the execute screen, Safe warned: "This transaction will most likely fail."

eth_call of execTransaction returned success. eth_estimateGas reverted. Binary-searching the gas limit with eth_call showed the batch needs about 21.3M gas: each new Uniswap v3 pool costs roughly 4.9M gas to deploy.

Base enforces a per-transaction gas cap of 16,777,216 (2^24, EIP-7825) since its Azul upgrade. A transaction above it is rejected. Our fork rehearsal ran on Anvil, which does not enforce that cap, so it never showed up.

The fix

We split the Liquidity batch into two Safe transactions with the same calls and amounts:

USDC and USDT pools, approve, two mints: 5.7M gas
WETH and cbBTC pools, two mints: 10.3M gas

Once the pools existed, the Public Launch batch (pool creation calls become no-ops, then approve and four mints) needed only 1.35M gas and ran unchanged. We replayed the three transactions in order on an Anvil fork before collecting new signatures. On chain, the four pools hold 5,000,000 ARL, the same numbers as the rehearsal.

Takeaways

Check every planned transaction against the chain's per-transaction gas cap, not only the block gas limit.
A fork rehearsal does not enforce EIP-7825 unless you check gas used yourself.
A reverting eth_estimateGas next to a succeeding eth_call is a strong hint that you are above a cap.

Addresses and the full runbook are in the repository: https://github.com/armanalabsai/arlcoin.io/blob/main/docs/mainnet-plan.md

ARL token: 0xde91E6f39D50bBd875f831dcc1134A3D7f3aaDb4 (Base Mainnet)

Shipping a fixed-supply ERC-20 on Base: our pre-launch checklist

ARL Protocol — Fri, 23 Oct 2026 19:19:56 +0000

ARL is a utility token for AI and compute payments on Base. Before the Base Mainnet launch we wanted every step to be reproducible and public. Here is the checklist we ran.

1. Keep the token boring

The token is unmodified OpenZeppelin v5.6.1 ERC20 and ERC20Permit. The full 21,000,000 supply is minted once in the constructor, and there is no owner, mint, pause or upgrade. A CI check fails if the token's ABI ever gains a function.

2. Layer the checks

Static analysis: Slither (0 results) and Aderyn (5 issues, all triaged as false positives or by design)
271 Foundry tests; fuzz tests at 10,000 runs in CI and 200,000 in a deep campaign; 5 invariant suites
Halmos bounded symbolic proofs: 11 of 11 properties
Mythril symbolic execution on the runtime bytecode of the launch contracts

All raw outputs (JSON, SARIF) are in the repository, and a workflow reproduces them on every change.

3. Verify the run you sign

Contract addresses come from the deployer and the nonce alone, so a matching address does not prove the constructor arguments. We check the creation code against our build and every argument against the published plan before signing.

4. Rehearse on a mainnet fork

The whole launch day (Safes, contracts, verification, Uniswap v3 pools) runs on a local fork of Base Mainnet with the real signers. It passed again today.

Report: https://arlcoin.io/docs/security-audit
Code: https://github.com/armanalabsai/arlcoin.io

Who decides that an agent's job is done? A staked committee on Base Sepolia

ARL Protocol — Sun, 18 Oct 2026 13:45:00 +0000

In ARL, a client pays an AI agent through an ERC-8183 job escrow. The open question is who decides that the work was delivered. We have deployed a first answer on Base Sepolia: ARLVerifiedEvaluator.

How it works

The client opens a job and names a committee of staked validators, a vote window, a challenge window and a bond.
The provider approves the committee, and the client funds the job.
Each validator accepts and locks a bond: max(1 ARL, budget / 10).
The provider submits a result hash and the validators vote. When the threshold is reached, the verdict is set.
During the challenge window anyone can dispute by posting a bond. Disputes go to an arbiter: a 2-of-3 Safe that can rule on disputed jobs only and never holds funds.
After the window the job is finalized, the provider is paid, and the outcome is written to ERC-8004 reputation.

What is deployed (Base Sepolia, testnet)

Contract	Address
Evaluator (source verified)	`0x6808F80Eb11538543d31cf4b50332B268dDd4d14`
Arbiter Safe (v1.5.0, 2-of-3)	`0x8FF6c3aD0991Ac848BFf5d0acD78BBc5e190466f`
Job escrow (ARLJobs)	`0xec79a897105aEd6daFBbB2a904E5bcFF71455644`

First job

Three validators staked 100 testnet ARL each, accepted job 1 and approved it 2-of-3.

Status

LIVE on Base Sepolia. The ARL contracts went through an internal security audit on 17 October 2026; the evaluator was added after it and is covered by its own tests, fuzzing, invariants and static analysis. Nothing is deployed on Base Mainnet yet, and testnet ARL has no value.

Design and code: docs/verifiable-execution.md
Try staking and jobs with testnet ARL: arlcoin.io/app

How AI agents can pay for AI services per call: x402 "upto" payments on Base

ARL Protocol — Sat, 17 Oct 2026 10:54:23 +0000

A ceiling the payer signs, a metered amount the service settles, and no API keys

Most AI services still sell access the way SaaS did in 2015: an account, an API key, a monthly plan and an invoice. That works for a human team. It does not work for an AI agent that needs to call a model it found a minute ago, pay for 3,000 tokens and move on.

The problem with fixed-price payments

HTTP 402 "Payment Required" has existed since the 1990s. The x402 standard finally gives it a format: a service answers 402 with its price, and the client retries with a signed payment. The catch is that AI usage is rarely known in advance. A request might use 200 tokens or 20,000.

"upto": sign a ceiling, settle the meter

The x402 upto scheme solves this. The payer signs an authorization for at most a ceiling, for example 5 ARL. The service does the work, measures it and settles only the metered amount, for example 1.37 ARL. The signature names the payee and can be used once. The service cannot take more than the ceiling, and cannot pay itself twice.

Who is the service? ERC-8004

Paying per call only works if the agent can trust whom it is paying. ERC-8004 gives services and compute providers an on-chain identity, with feedback and ratings that other agents can read before they pay.

Longer work: ERC-8183 escrowed jobs

Some tasks, such as a training run or a batch of renders, take hours. For these, ARL uses ERC-8183 jobs. The client locks the payment in escrow with a deadline, the provider delivers, and the escrow releases the payment or refunds it.

Try it

ARL Protocol puts these pieces together on Base. Everything is open source and live on the Base Sepolia testnet. At arlcoin.io/app you can take testnet ARL from the faucet, pay a demo service with an x402 upto payment, post an escrowed job and stake. Testnet tokens have no value.

Code: github.com/armanalabsai/arlcoin.io
Docs: arlcoin.io/docs
Community: t.me/arlcoin_community · X @arlprotocol

Originally published on Medium: https://medium.com/@armanalabsai/how-ai-agents-can-pay-for-ai-services-per-call-x402-upto-payments-on-base-4cd395e3d08f