The problem: agents buy inference like humans do
An autonomous system consuming inference today inherits a stack built for people: one account, one key, and one bill per provider; prices that shift under you; subscriptions and credit packs that pre-buy tokens you may never use; payment rails that assume a card and a checkout page.
And agent traffic has a shape human traffic doesn't: it repeats. Retries, eval sweeps, and agent loops resend the same calls thousands of times, and when you go direct, every one of those repeats bills at full price. Nobody in the direct path has an incentive to de-duplicate your spend.
What Arca is: a gateway, priced straight
Arca is an inference gateway, in the same category as OpenRouter: one OpenAI-compatible endpoint and one key in front of a catalog of frontier models, with the actual GPUs operated by upstream providers we route to. We don't own the silicon, and we don't claim to. What we own is the routing layer, the cache, and the payment rail, and that's where the savings live. The bill has exactly one line:
call cost = (prompt tokens × model input rate)
+ (output tokens × model output rate)
// no per-call fee. no gas. no subscription. nothing else.The token rates, what the catalog lists, are the whole price. They cover the upstream compute and the gateway's keep, and nothing rides on top of them: no platform percentage, no per-call surcharge, no credit float, no subscription floor. Compare the posted rate to going direct, that comparison is the product.
Where the savings come from
A gateway can't reschedule a GPU, so we don't claim wins that live in the serving plane. The mechanisms below are the ones a routing layer legitimately owns, and their effects compound:
Smart routing
Multiple providers serve the same open-weight models at different prices, latencies, and health states. The gateway scores live routes per call and sends your traffic down the best one, when a cheaper route appears, your cost drops with zero code change.
Exact-response cache
Identical repeat calls (retries, evals, agent loops) are served from the response cache at half-price tokens and ~10ms, per-tenant isolated. This one is a billing rule, not just an optimization: the discount is posted.
Tier routing
The catalog is tiered High / Balanced / Eco so agents buy exactly the intelligence a task needs. The cheapest token is the frontier token you didn't need: routing classification traffic to Eco is a 10–50× saving before any routing trick.
Prefix-aware routing
Agents resend the same system prompt and tool schemas thousands of times a day. Where upstream capacity supports prefix caching, the gateway prefers those routes, so the most expensive part of an agent's request prices cheaper on repeat.
Automatic failover
When a route degrades, traffic shifts to the next-best one mid-stream. You see one endpoint and one uptime number instead of building retry ladders across providers yourself.
No platform overhead
One key, one wallet, one bill across the whole catalog. No per-provider accounts, no subscriptions, no pre-bought credits expiring on a shelf.
How a call routes
Every request takes the same path through the gateway, and the decision happens per call, not per model:
Request arrives
Every call hits the response cache first (Mechanism B). An exact repeat is served in ~10ms at half-price tokens, no routing decision needed.
Route selection
The gateway scores the live upstream routes serving that model on price, latency, and recent health, and picks the best one. Prefix- and tier-aware rules bias the choice toward the cheapest route that meets the call's needs.
Failover if needed
If the chosen route degrades or errors, the call re-routes to the next-best capacity automatically. You never see the shuffle, just the response.
One honesty rule governs the whole catalog: we say what we are. Arca is the gateway and the cache, the GPUs belong to the providers we route to, and models carrying an explicit 3rd Party Provider tag are labeled as such. We'd rather post an accurate label than a flattering one.
The payment rail: one asset, zero gas
The second advantage is that paying Arca was designed for machines. Your wallet holds one asset, USDG. That's the whole setup:
- No gas, ever. Settlement rides a gasless payment protocol, you never hold a second token just to pay transaction fees, and no call ever fails because a gas balance ran dry.
- Fair by construction. Calls are metered at their exact token count and billed against posted rates, no credits, no rounding into bundles, no subscription floor.
- Pre-authorize, then refund. Accountless calls quote a ceiling up front and automatically refund the difference between the ceiling and the actual metered charge. You can cap any key's lifetime or rolling spend on top.
- Machine-speed settlement. Each call settles itself on-chain in the background, an agent can transact with Arca with no human, no card, and no account state to manage.
A worked example
Assumptions, stated plainly: 100 calls of 5k input + 20k output tokens on a Balanced-class model posted at $0.30 / $0.90 per 1M tokens, the same rates you'd pay going direct. The savings come from the cache: repeat calls bill half tokens. Change the hit rate and the gap changes, that's the point of showing it.
tokens × $0.30 / $0.90 per 1M. every call pays full price
cached calls bill half tokens
retries, evals, and loops repeat a lot
In this shape: ~15% saved at a 30% cache hit rate, ~30% at 60%. Cache-friendly agent workloads, retry-heavy loops, eval sweeps, repeated tool calls, are the ones that reach up to 30%; unique, one-off calls pay the posted rate, which is the point of posting it. Smart routing and tier routing land on top of this, but they vary per workload, so we don't put a single number on them. Illustrative, live prices are always on the models page, and the math is yours to check.
The flywheel
A gateway gets better the more traffic flows through it. Volume earns better terms with upstream capacity, which the price sheet passes on; more traffic means more repeats, which raises cache hit rates; more routing data means sharper route selection. Every call makes the next one slightly cheaper. Half of every call's revenue funds monthly distributions to $ARCA holders (see Rewards); the other half funds the network. The gateway gets cheaper because it gets used.
Roadmap
- Response cache GA, half-price repeat calls, on by default, per-tenant isolated.
- Prefix-cache-aware pricing, passing cached-prefix savings from upstream routes into the posted input rate for agent-shaped workloads.
- Prepaid sessions, deposit once, spend from an off-chain balance at ~10ms per call; one settlement covers many calls.
- Distribution engine, automated monthly holder payouts, pro-rata to supply.
- Route expansion, more upstream capacity, more models, same price-sheet discipline.