Bearer or x402 walk-up? A decision tree for agent operators

The same POST to /v1/chat/completions can produce two different invoices. With an Authorization: Bearer header it debits a prepaid balance you funded last week. With an X-PAYMENT header it settles a signed USDC authorization from a wallet the gateway has never seen before. Walk-up list prices run 10 percent below Bearer. And yet the choice between them is almost never a pricing decision — it is a business-model decision about who pays for the call.

Every paid surface on the platform accepts both modes: the OpenAI-compatible gateway and nearly all of the 67 MCP tools. That symmetry is deliberate, and it produces a real fork in the road for the operator. This post is the decision tree — what each mode actually is, where the 10 percent misleads, and the mixed pattern most operators end up running.

Bearer: the operator's mode

Bearer is the developer experience you already know. You register an agent, deposit USDC or USDT on Polygon or Solana, and get an API key. Every call carries Authorization: Bearer and debits the balance:

$ curl https://api.llm4agents.com/v1/chat/completions \
    -H "Authorization: Bearer $LLM4A_KEY" \
    -d '{
      "model": "anthropic/claude-fable-5",
      "max_tokens": 1000,
      "messages": [{"role": "user", "content": "..."}]
    }'

// Response headers:
X-Cost-Usd-Cents: 7.0
X-Balance-Remaining-Cents: 4923.5

Under the hood, Bearer runs the reserve-proxy-settle ledger: the gateway holds the worst-case cost before the request leaves, forwards the stream untouched, then settles the actual cost and refunds the difference. The properties that fall out of that pattern define the mode. You pay for real usage, never for the ceiling. Failed fallback attempts cost nothing, so chains are economically free. Every call lands as one row in /api/v1/transactions, so a fleet has one ledger and one number to reconcile. And the MCP server's 60-requests-per-minute free tier only exists in this mode, because a free tier needs an account to attach to.

Bearer fits one shape of business: you operate the agents, and inference is your cost of goods. If you sell a SaaS product at $80 per month per customer and your agents burn tokens serving them — the model from our fleet economics post — you want costs pooled, refunds automatic, and a single invoice-shaped ledger. Your customers never see the meter. You do, in one place.

x402 walk-up: the stranger's mode

Walk-up inverts every assumption. There is no account, no key, no deposit, no relationship. An agent calls the endpoint cold, receives HTTP 402 with a quote, signs a stablecoin authorization for that exact amount, and retries. The payment is the credential:

// 1. Cold call → 402 with the quote (decoded):
{
  "x402Version": 2,
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:8453",       // Base mainnet
    "amount": "9000",                // $0.009 in 6-decimal USDC
    "payTo": "0x0D74...8C12",
    "maxTimeoutSeconds": 300
  }]
}

// 2. Sign EIP-3009 transferWithAuthorization, retry with X-PAYMENT.
// Or let the SDK do the whole dance:
const completion = await client.chat.completions.create({
  model: 'anthropic/claude-fable-5',
  max_tokens: 1000,
  messages: [{ role: 'user', content: '...' }],
  paymentMode: 'x402',      // pay per call, no balance, no account
});

What the agent signs is an EIP-3009 transferWithAuthorization: an EIP-712 typed message binding from, to, value, a validAfter/validBefore window, and a random 32-byte nonce that the token contract marks as consumed — one authorization, one settlement, ever. Random nonces are the detail that matters for agents: unlike sequential transaction nonces, a wallet can have dozens of authorizations in flight concurrently without collisions. The full protocol walkthrough is in our x402 deep dive.

Walk-up fits the opposite shape of business: the caller pays for the caller's usage. A third-party agent that consumes your endpoint once and disappears. A one-shot research process that should not inherit anyone's API key. An agent roaming infrastructure it has no account on. Per-use billing where each request carries its own receipt, settled on-chain, final.

The 10 percent is not the decision

Walk-up prices sit 10 percent below Bearer across the catalog: a 1¢ tool costs 0.9¢, ai_embed's 0.1¢ becomes 0.09¢. The discount rewards settlement that is immediate and final — no refund machinery, no ledger to maintain, no account risk. For MCP tools, whose prices are flat per call, the discount is exactly what it looks like. Take it.

For LLM inference, the arithmetic is sneakier, and it comes from one asymmetry: Bearer settles actuals; walk-up settles the quote. The x402 exact scheme transfers a fixed amount with no delta-refund path, so the walk-up price must be the worst case — the same reserve formula Bearer uses as a temporary hold, made permanent. The billing internals post worked this example: 3,000 input tokens against Claude Fable 5 at $10 input / $50 output per million. Run it in both modes:

// Same call, max_tokens: 4000, model answers in 800 tokens
Bearer:   reserve 23.0¢ → settle 7.0¢, refund 16.0¢  →  you paid  7.0¢
Walk-up:  quote = 23.0¢ x 0.90                        →  you paid 20.7¢

// Same call, max_tokens: 1000
Bearer:   reserve  8.0¢ → settle 7.0¢, refund  1.0¢  →  you paid  7.0¢
Walk-up:  quote =  8.0¢ x 0.90                        →  you paid  7.2¢

With a sloppy token budget, walk-up costs three times Bearer despite the discount. With a tight one, the modes converge to near parity. The rule compresses to one sentence: the 10 percent goes to whoever sets max_tokens honestly, and the worst-case premium is charged to whoever does not. Tools are immune because their prices are flat; inference is where discipline is priced.

The decision tree

Walk the questions top to bottom; the first column that keeps matching is your mode.

Question                       Bearer                        x402 walk-up
Who funds the call?            You — operator balance        The caller's wallet
Gateway relationship           Account + API key             None — payment is the credential
Billing model you sell         SaaS subscription; COGS       Per-use; each call self-settles
Inference settlement           Actuals, delta refunded       Quote, final, no refund
MCP tool price                 List (1¢ ...)                 10% below list (0.9¢ ...)
Free tier                      60 req/min on MCP             None
Cold-call latency              One round trip                +1 round trip + on-chain verify
Accounting artifact            One ledger row per call       One on-chain receipt per call
Fallback chains                Economically free             Priced at worst link, kept
Coverage                       Everything                    All but web_crawl, pdf_parse,
                                                             doc_extract (balance-only)

Three rows deserve a note. Latency: a cold walk-up adds a 402 round trip plus facilitator verification — noise on a 500ms completion, material on a 30ms tool call, which is why high-frequency short calls belong on Bearer. Chains: a fallback chain reserves at its most expensive link; on Bearer the refund returns the difference when a cheap link answers, on walk-up the worst-link price is what you signed. Chains only make economic sense on Bearer today. Compliance: Bearer gives a fleet operator one reconcilable ledger; walk-up gives each transaction an independent on-chain receipt — which of those your accountant prefers depends entirely on whether the spend is yours or your callers'.

Mixed mode: the pattern operators converge on

The modes are not exclusive, and the most durable configuration uses both — split by whose money moves.

Your product's own traffic runs on Bearer. The agents you operate, serving customers who pay you monthly, draw from one pooled balance with refunds, chains, the free tier, and a single transaction log. That is inference as COGS, and Bearer is simply the better ledger for it.

Your public surface quotes x402. The moment you expose anything for third parties to consume — a research pipeline, a data endpoint, a specialist agent another agent might hire — walk-up means strangers pay their own way with zero onboarding. You do not issue keys to unknown agents, meter their quotas, or chase their invoices. The 402 quote is the price list, the signed authorization is the payment, and the settlement receipt is the contract. Our x402 post called this agent-to-agent commerce; mixed mode is what it looks like from the seller's chair.

There is a third party whose money can move: your end user's. When an agent buys on behalf of a human — the agent pays, but the mandate to spend came from someone else — the payment rail alone does not answer the question that matters, which is whether the human authorized this purchase. That is what AP2 exists for: Google's agent payments protocol wraps the transaction in signed mandates, verifiable credentials recording what the user permitted, now moving through FIDO working groups toward standardization. AP2 treats x402 as one settlement method among several, so the stack composes cleanly: the mandate proves the authority, the x402 authorization moves the money. If your agents spend user funds, walk-up plus a mandate trail is the defensible configuration — our AP2 post covers the mandate mechanics in depth.

What it means for LLM4Agents

Dual-mode is the platform's wedge, and it is worth being explicit about why. Pure-Bearer platforms — effectively every traditional API vendor — compete on developer experience and lock the door to anonymous callers. Pure-x402 endpoints compete on openness and give up the refundable ledger that operators running fleets actually need. Serving both modes through one meter means an operator can start Bearer on day one, expose an x402 surface the day they get their first third-party caller, and never migrate platforms to do it. The fleet economics arithmetic also quietly depends on this: the margin models in that post assume refunded reserves and pooled balances, and the revenue models assume strangers can pay per call. One platform underwriting both sides of that spreadsheet is the product.

The honest exposure is the worst-case premium on walk-up inference. Today it is defensible — the exact scheme physically cannot refund a delta. But any competitor that ships variable-amount settlement first erases walk-up's biggest weakness overnight and takes the per-use market with it. That risk now has a name and a spec.

Staying on the frontier

Four moves, in order.

One — implement the upto scheme. The x402 spec now includes upto: the client authorizes a maximum, the server settles the actual amount at or below it, each authorization settles at most once, and a zero charge is permitted if nothing was consumed. That is reserve-proxy-settle economics on a walk-up rail — exactly the development our billing internals post flagged as the thing to watch, now published, currently EVM-only. Shipping upto support collapses the worked example above: walk-up inference would settle actuals like Bearer does, and the 10 percent discount would become unconditional. This is the highest-leverage item on the platform's payment roadmap.

Two — publish the quote as a dry run. An endpoint that returns both effective prices for a request — Bearer's expected settle and walk-up's quote — without executing it. The decision tree above should be computable by the caller, per call, before any money moves.

Three — accept AP2 mandates on walk-up calls. Let a caller attach a mandate credential alongside X-PAYMENT and store it with the settlement receipt. For agents spending user money, the audit trail becomes turnkey rather than an operator-side chore.

Four — ship a mixed-mode starter. A template repo wiring one agent with Bearer for its own reasoning and an x402-quoted endpoint for its public service. The pattern in this post should be a clone command, not an architecture exercise.

Closing

Two headers, two invoices, one decision: whose money moves. Bearer is the ledger for spend that is yours — actuals settled, deltas refunded, one log. Walk-up is the rail for spend that is theirs — no account, immediate finality, a receipt per call, priced at the worst case until upto lands. The 10 percent discount is real but marginal; the business-model fit is what compounds. Pick per call, not per platform — the gateway was built so you never have to choose once.