Whitepaper · Bull Router

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 Bull Router is: a gateway, priced straight

Bull Router 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.

cache miss

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.

StateServed byWhat you pay

Cache hitResponse cache, per-tenant~10ms · half tokens

Cache missBest live upstream routeposted rate

Route degradedAutomatic failover routesame rate

One honesty rule governs the whole catalog: we say what we are. Bull Router 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 Bull Router was designed for machines. Your wallet holds one asset, USDC. 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 Bull Router 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.

Going direct, list rates, no cache$1.95

tokens × $0.30 / $0.90 per 1M. every call pays full price

Bull Router with 30% cache hit rate$1.66

cached calls bill half tokens

Bull Router with 60% cache hit rate (agent loops)$1.37

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.

Two tokens, two roles

The economic model has exactly two moving parts, and they don't overlap. One token opens the gateway; the other pays the people who push traffic through it. Only the second one is ours: $ANSEM is a community token created by Ansem and trading on Solana independently of this gateway. Bull Router did not issue it, does not control its supply, and takes no cut of it, we read a wallet balance and grant access.

$ANSEM

Access

Community token · created by Ansem, not issued by Bull Router

Hold 250+ $ANSEM to unlock 3M free inference tokens every week. Holding is the key, not a subscription, a credit pack, or a card.

$BULLROUTER

Rewards

Native token · issued by Bull Router

Use Bull Router, generate inference activity, and compete for a share of the weekly $BULLROUTER reward pool funded by 20% of creator fees.

The distinction is the whole design: $ANSEM unlocks access to free inference, while $BULLROUTER rewards actual usage. Nothing is paid for holding $BULLROUTER, announcing intent, or waiting, the only input the reward pool reads is inference served. Full detail on the tokenomics page.

Weekly usage rewards

Every week, Bull Router tracks inference activity across the network. At the end of each weekly epoch:

Top 10 inference users share 20% of the creator fees generated during that period, distributed in $BULLROUTER.
The remaining creator fees support development, infrastructure, liquidity, and the long-term sustainability of Bull Router.

Rewards are proportional among the Top 10 rather than ten equal slices. A user's share of the weekly pool is their eligible inference usage relative to the combined usage of the Top 10:

your share = weekly pool
             × ( your eligible usage
                 ÷ combined usage of the Top 10 )

// pool = 20% of creator fees for the epoch

Proportional beats flat here for one reason: it keeps the incentive pointed at real inference volume instead of a place on a list. Rank alone pays nothing, and the heaviest user earns the largest slice because that user generated the fees the pool is made of. An interactive worked example lives on the Earn page.

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.

The token model puts the same loop on the demand side: more inference usage means more protocol activity, which means a larger weekly reward pool, which means more incentive to route through Bull Router. The whole economy compresses into one line:

hold $ANSEM → get inference → use Bull Router
  → generate fees → earn $BULLROUTER → grow the network

The gateway gets cheaper because it gets used, and the people who use it hardest are the ones the fees pay back.

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.
$ANSEM access gating, the 250+ $ANSEM balance check that mints 3M free inference tokens onto a key every week.
Weekly reward epochs, usage accounting, the Top 10 leaderboard, and automated proportional $BULLROUTER payouts from 20% of creator fees.
Route expansion, more upstream capacity, more models, same price-sheet discipline.

The economics of machine-speed inference.