Cover photo

The state of programmable payments on Arc — what the data says

By Abu Olumi — Edition 2 of Building on Arc

Edition 1 ended on May 23 with a crash, a fix, and a summary of the first seven days: 200k+ blocks scanned, 2k+ autonomous agent cycles, $30+ USDC spent. Two weeks have passed since then. The numbers have grown significantly. A weekly intelligence report generated successfully but never made it to the dashboard. And the agent's spending pattern across three weeks of live operation has produced a dataset worth examining closely.

Since ArcSense launched publicly on May 7, the autonomous agent has spent $370.20+ USDC on intelligence — every payment a real on-chain transfer, every decision logged, every transaction verifiable on Arc Explorer. This is what the data says about programmable payments on Arc.

Week 2: the data

Week 2 ran from May 22 to May 30 — eight days following the redeploy that fixed the Math.max crash. The agent completed 2,329 cycles and spent $225.80 USDC on intelligence.

The headline number masks what was actually happening. By May 27 — just five days into the week — the agent had already spent $66.20. That figure was shared publicly at the time. The full week ended at $225.80, more than three times the May 27 figure, because the failure rate spike that began on May 27 continued driving autonomous spending for the remainder of the week.

On May 27, Arc Testnet failure rate climbed from 1.9% to 3.92% over the course of a single day. The agent crossed its 3% payment threshold and kept buying block intelligence and contract risk scans continuously for the duration. $47.40 USDC in 24 hours alone. Every payment was a real on-chain transfer from the agent wallet to the service wallet. Every decision logged with the reasoning, the urgency level, and a clickable Arc Explorer transaction link. The agent was not spending blindly — it was responding to a specific on-chain condition, escalating spending in proportion to the severity of that condition, and de-escalating when it passed.

The weekly report that generated but never surfaced

On May 29 at 17:27 UTC, the ArcSense weekly report generator fired after eight days of accumulated block data. It computed the health score, aggregated failure rates across every block scanned that week, identified the most volatile block, ranked the top failing contracts, and generated a plain-English insight. It wrote the output to a JSON file on Railway's filesystem and logged the confirmation to the terminal.

Then nothing happened on the dashboard. The Weekly Reports modal showed "NO REPORT YET."

The reason was straightforward: I had built the report generator but never built the API endpoint to serve the generated file. The JSON was sitting on Railway's ephemeral filesystem with no route to expose it. A fully functional piece of infrastructure with no way to observe its output.

The fix was ten lines of code — a GET /reports/weekly endpoint in index.ts that reads the latest weekly JSON file from disk and returns it. But by the time the fix was pushed, Railway redeployed, the ephemeral filesystem reset, and the report was gone.

This pattern shows up repeatedly in production systems. The generation side gets built because it is the interesting engineering problem. The serving side — the endpoint, the dashboard integration, the observability — gets deferred because it feels like plumbing. The consequence is infrastructure that works but cannot be seen. A report that proves the system ran correctly, accumulated real data for eight days, and produced a meaningful output — and was completely invisible to anyone using the product.

The lesson is simple: every artifact a system generates needs a corresponding way to surface it, built at the same time. The generator is not complete until its output is reachable.

Week 3: the data

Week 3 ran from May 30 to June 5. The agent completed approximately 1,185 cycles and spent $48.20 USDC before a forced reset today. That is significantly less than Week 2's $225.80 — and the reason is straightforward. The failure rate spike that drove Week 2 spending had passed. The network stabilized in the days following May 30, failure rates dropped back below the 3% threshold, and the agent responded accordingly. Fewer conditions met. Less intelligence purchased. Less USDC spent.

This is the property of demand-driven payments that fixed subscription models do not have. A subscription service charges the same amount regardless of what the network is doing. A demand-driven system concentrates spending around periods of elevated activity and scales back when those periods pass. The Week 2 to Week 3 spending ratio — $225.80 to $48.20 — is a direct reflection of network conditions, not a billing cycle.

The payment architecture decision

When I built the verification layer for external payments, I had two options for confirming that a developer had sent USDC to the service wallet.

The first option was Circle's transaction indexing API. Managed, well-documented, and purpose-built for this use case. The problem was latency. On Arc Testnet, Circle's indexing endpoint had a delay of several minutes between a successful on-chain transfer and the transaction appearing in the API response. For a pay-per-query system where a developer sends 0.1 USDC and waits for their credit to unlock, several minutes is an unacceptable experience.

The second option was Blockscout. Arc Testnet's explorer provides a transaction API that returns confirmation data almost immediately after a transaction is included in a block. The tradeoff is that Blockscout is a third-party dependency rather than Circle's managed infrastructure, but for the current state of Arc Testnet it delivers a substantially better developer experience.

The result is a two-track verification system. For agent-to-service transfers where both wallets are Circle-managed, the Circle API handles verification cleanly. For any external wallet — MetaMask, Rabby, or programmatic — Blockscout handles verification immediately. Send 0.1 USDC, call the confirm endpoint with the wallet address and transaction hash, receive the credit within seconds. No Circle account required. No SDK. Any EVM wallet on Arc works.

The friction that still exists

Two issues in the Circle Developer Wallet setup cost significant debugging time and are worth documenting for any builder attempting the same integration on Arc.

The first is the feeLevel parameter. Arc Testnet transactions require an explicit fee level — MEDIUM works reliably — but this is not documented specifically for Arc. The Circle API returns a generic parameter validation error with no indication of which parameter is wrong. Debugging from first principles without chain-specific documentation took most of a day.

The second is the entity public key required for Circle API request signing. The official documentation assumes this key lives in a local file. In a cloud deployment like Railway where the filesystem is ephemeral, storing a multi-line PEM key as a file that gets read on startup is unreliable. The correct approach is storing it as an environment variable with proper newline handling — undocumented in the official Circle guides and another day of debugging to discover.

Both issues are solvable. Neither represents a fundamental limitation of the payment infrastructure. But for a developer building on Arc for the first time, these are the exact friction points that turn a two-day integration into a four-day one. The payment infrastructure is ahead of the documentation that explains how to use it on Arc specifically.

What three weeks of spending data reveals

The pattern across three weeks is the clearest evidence that ArcSense's payment model works as intended.

Week 1 ($30+): Early operation, network relatively stable, agent learning the rhythm of Arc Testnet activity.

Week 2 ($225.80): A significant failure rate spike drove heavy autonomous spending. The agent calibrated its response — buying more intelligence as conditions worsened, spending $47.40 in a single 24-hour period at the peak, then continuing at elevated levels until the spike subsided.

Week 3 ($48.20): Network stabilized. Agent spending dropped back accordingly.

The $370.20+ total is not a fixed charge. It is the accumulated output of an agent making 3,500+ individual spending decisions across three weeks in response to real on-chain conditions. That is what programmable payments look like when they are working.

The state of programmable payments on Arc

Three weeks of real data produces a clear picture. The primitives for programmable payments on Arc are functional. USDC transfers work reliably. On-chain verification via Blockscout is fast enough for real use cases. Autonomous agents can hold wallets, make decisions, and execute payments without human input across thousands of cycles. The payment confirmation flow works from any EVM wallet with no additional infrastructure required.

What is missing is documentation and observability. The Circle Developer Wallet integration needs a guide covering Arc-specific requirements. The infrastructure for generating artifacts needs equal attention paid to the infrastructure for surfacing them — the weekly report that disappeared into an unreachable filesystem is the clearest illustration of that gap.

The infrastructure is ahead of the guides. That will change.

ArcSense will keep running. The agent will keep spending. Edition 3 covers what the first weekly intelligence report that actually makes it to the dashboard reveals about Arc Testnet activity patterns.

Dashboard: arcsense-lite.vercel.app

API: arcsense-lite-production.up.railway.app

GitHub: github.com/2TheMoom/arcsense-lite

Edition 3 — Saturday June 20, 2026: "Week 4 on Arc — what the first surfaced weekly intelligence report reveals"