ACR

Demo

About

Every institutional trading desk runs transaction-cost analysis on its fills: did I pay more than the market at the moment I traded, and to whom? No AI agent has ever been able to ask that, because there was no benchmark to ask it against. Agents pay per call for inference, GPU time and data at whatever that seller quotes that hour, and nothing tells them they overpaid. ACR is the benchmark. It is a live, on-chain reference rate for machine compute on Arc (ACR-INF, ACR-GPU, ACR-DATA), recovered hourly from Arc's own USDC payment exhaust by a manipulation-resistant estimator, signed by a Circle custody wallet, and published with a confidence interval and the USDC an attacker would have to burn to move it one basis point. That existed before ETHOnline. It is the frozen baseline and claims no credit here. What was built during the event is Machine TCA, the first transaction-cost analysis for AI agents, in four parts. Benchmark, in public. Every x402 nanopayment settlement on Arc is benchmarked inside a subgraph mapping against the ACR print the payer could have seen at the block it traded (the arrival-price convention, the standard implementation-shortfall measure). The slippage in basis points is computed by The Graph, not asserted by us, and anyone can query it. make recompute re-derives the index from the indexed tape and checks it against the chain. Rate. Sellers get A–D grades from the same tape (fairness, cleanliness, human depth, attestation freshness), with the sample size and the synthetic share printed on every card, so a reroute points somewhere actually fair rather than merely cheap. Humans, not wallets. Wallets are free; people are not. HumanIdMirror records, per week, which wallets act for one verified human as a rotated cluster id, never a World ID nullifier, so the manipulation bound can be denominated in people. ACROracleV2 posts that human-adjusted bound beside the wallet-denominated one. An agent can present a proof and get one TCA across every wallet its human owns, and the API gate meters all of a person's keys as one budget: ten wallets, one bill. A human claim the chain cannot confirm is a 401, not a downgrade. Reach. Six read-only MCP tools (my_tca, reroute_suggestion, seller_rating, benchmark_price, get_rate, query_tape) put TCA inside any agent host, and an "Ask the Tape" skill lets a judge interrogate the live subgraph in plain English through The Graph's own Subgraph MCP. The loop closes in CI and on camera. The buyer agent reads its own TCA, sees which seller it overpaid, and moves its next Circle Gateway nanopayment to the one it overpaid least; that settlement is indexed with its own slippage, so the agent's TCA improves from public data. Three such reroute settlements are archived from CI's own buyer, and a drivable version lives at arc-compute-rate.vercel.app/loop. Stated plainly: this is a Continuity project. Baseline tag v1.0-submission; 45 commits and 41,200 insertions since, 91.6% of them in files that did not exist before, 0.7% baseline churn, all re-derivable from CONTINUITY.md. The testnet tape is partly our own flow, flagged synthetic on chain and disclosed on every card. Demo identities are World ID Sandbox identities, flagged the same way. Arc mainnet opens Sep 16: ACR is deployment-ready with a chain-id-checked runbook and a dry run of all five deploys, not deployed. Seven contracts are live on Arc testnet, three of them new. 677 Python, 156 Foundry, 159 terminal and 31 agent tests are green, and a CI audit re-measures every number in the docs, including these. Live: arc-compute-rate.vercel.app · API acr-api-1fto.onrender.com · Subgraph Studio ethonline v0.2.0 on arc-testnet · github.com/kaustubh76/ACR---Arc-Compute-Rate

How it's made

The stack, layer by layer. The estimator is Python: a Kalman-class state-space deconvolution of Circle Gateway's batching operator (payments arrive batched, so a naive VWAP measures the scheduler, not the market), a Louvain-clustered sybil and wash cleaning stage, an α-trimmed volume-weighted median, and a hedonic regression that strips seller quality to leave a constant-quality rate, with a manipulation-cost bound published beside every print. Contracts are Solidity on Foundry, live on Arc testnet: ACROracle, ACROracleV2, AttestationRegistry, ACRFutures, FeedAccessAttestor, ReceiptMirror and HumanIdMirror, with unit and invariant suites. The x402-gated API is FastAPI, the terminal is Next.js, the buyer agent is TypeScript on Circle's @circle-fin/x402-batching, the subgraph is AssemblyScript on Subgraph Studio, and the MCP server is TypeScript. Everything runs credential-free against a calibrated simulator; every live path is additive. Arc. USDC is the gas token and fees are deterministic, which is the only reason "attack cost per basis point" is a number rather than a distribution. Three contracts were added during the event. ReceiptMirror puts every x402 settlement on chain as raw features only (unit, quantity, synthetic flag) so the subgraph can benchmark it. HumanIdMirror records weekly human clusters. ACROracleV2 extends the print with a cleaning-policy hash and the human-denominated bound, keeping v1's six signed fields as a strict typehash prefix so the immutable ACRFutures.oracle is never orphaned. Mainnet: make deploy-mainnet-dry simulates all five deploys with a chain-id preflight. The Graph is load-bearing, not decorative: the slippage number is computed in the mapping. The hard part was timing. The arrival price must be the print at the trade block, but the quantity needed for a unit price arrives in a later ReceiptMirror block. So the Gateway settlement handler writes a mutable PendingSettlement that snapshots the LatestPrint at the trade block, and the ReceiptMirror handler reads that snapshot, computes unit price and slippageBp, and creates the immutable Settlement. The keeper never supplies an arrival price, so it cannot flatter one. Daily seller and payer roll-ups are maintained in the mapping with a seven-bucket slippage histogram (the schema deliberately avoids @aggregation and says why), and the p50 is interpolated from the histogram because there is no median in a sum. Studio on arc-testnet indexes about three seconds behind head. acr recompute --rederive-cleaning re-clusters from on-chain funding edges under the policy hash each print carries and reports whether its exclusions match the keeper's, so the one keeper-authored step is re-derivable rather than trusted. The acr-analyst skill carries the schema map, unit conventions and six canned questions so The Graph's Subgraph MCP can answer a judge in plain English. World. HumanIdMirror stores keccak256(nullifier, salt, window), never the nullifier, and the salt commitment is an immutable constructor argument, so the resolver cannot retroactively regroup wallets into whichever clustering flatters a number. Every cluster carries a sandbox flag from the signed message through the event into every rating, because every demo identity is a World ID Sandbox identity and the reader should not have to take the README's word for it. The proof path is a 401 challenge, a CAIP-122 signature, then /tca/human with the nonce spent on use; make prove-human runs it end to end with nothing secret. The API gate has three tiers: anonymous shares a host ceiling, carded gets a per-key bucket via an EIP-712 agent card, and human gets a per-person bucket because the card's cluster claim is checked against HumanIdMirror.clusterOf on chain. The card's domain deliberately names no verifyingContract, which is what permissionless means here: no registry, no allowlist, the gate believes the key. Circle. Gateway x402 nanopayments gate the API at $0.0001 a query on both sides, developer-controlled wallets sign every print, and the buyer uses the Agent Stack SDK. Two things cost real time: EIP-3009 needs a signature ecrecover can verify, so the hedger's smart account trades while its backing EOA pays; and circle wallet execute cannot build a transaction carrying a negative int256, so an agent on that path can open a position but never close one. One guard is not from any sponsor and is named rather than folded in. Agent-to-agent traffic (the carded subgraph read) passes Google Cloud Model Armor in both directions, fail-closed, from asia-south1. On 2026-09-12 it refused a prompt injection by name (pi_and_jailbreak) over the public internet, driven through the real endpoint rather than by calling the module. /armor/info reports which backend answered, because an offline pattern floor and Model Armor look identical from outside and only one of them is a screen. The hacky bits worth admitting. CI runs with zero secrets and stands up its own anvil, and a dedicated step fails the build if the on-chain suites skip, because a skipping test looks exactly like a passing one and that is how a real regression once stayed green for a day. scripts/verify_claims.py re-measures every count, address and diff statistic against the documents that state them, and CONTINUITY.md's numbers are anchored to a named commit range at both ends, because a statistic measured against HEAD goes stale the moment the commit correcting it lands. The free-tier API host pings its own public URL from its 60-second loop so the hourly press does not fall asleep with it. Arc's eth_getLogs has a hard cap near 15,000 blocks and separate 429 throttling, and a reader must never treat a throttle as a range error, because backing off the range once collapsed a 7.9-hour walk to eleven minutes. And a bare-digit find-and-replace on a test count once nearly rewrote an on-chain settlement price in the docs, so every count edit is anchored on its neighbouring words.