Services

The 'what' layer of the agent economy — the real services an agent buys and sells for Bitcoin.

In brief. Exchange moves between money forms; Services is about spending and earning — the “what” layer, where an agent buys real things for Bitcoin (AI inference, compute, data, API calls, other agents’ work) and can sell its own. It’s two-sided: agents are both customers and providers. This page covers how an agent pays (the Bitcoin-native mechanisms — L402, Cashu-as-API-key, NWC), what’s for sale, how it offers its own, a few curated venues, and the full community-rated directory at its own site, marketplace.bitcoineconomy.ai. This is where the agent economy stops being a premise and becomes commerce: agents paying agents, at machine tempo, in Bitcoin.

What Services is

The Case argues why an agent chooses Bitcoin; The Stack equips it; Exchange lets it cross between money forms. Services is the destination — the actual economic activity the whole stack exists to enable. An autonomous agent that holds value but never spends or earns it is a wallet, not an economic actor. Services is where it acts.

It is two-sided by nature:

• Consume. An agent buys what it needs to do its job — inference from a model API, compute for a task, a data feed, a paid API call, storage, or a service performed by another agent.
• Offer. An agent sells what it produces — its own inference, analysis, monitoring, or task execution — to other agents or to humans, and gets paid in Bitcoin.

The two sides together are what “the agent economy” actually means at ground level: not agents using money, but agents transacting — buying and selling from each other (agent-to-agent, A2A) at a frequency and granularity no human-mediated market produces.

How an agent pays for a service

This is the part that is genuinely agent-native, and it is what distinguishes Bitcoin-stack services from a human typing a card number. The Bitcoin-native mechanisms:

• L402. The canonical pattern. An agent requests a paid resource; the server answers HTTP 402 Payment Required with a Lightning invoice; the agent pays; it retries with cryptographic proof; the server issues a scoped credential — a macaroon carrying caveats like expiry and rate limit — that the agent reuses across the session. The payment leg is permissionless at the protocol layer; the conversion is from sats into machine-readable capability. For high-frequency, pay-per-call workflows this is the machine-tempo standard. (The tooling that implements it — lnget, Aperture, lightning-agent-tools — lives in The Stack.)
• Cashu-as-API-key. A bearer ecash token is the access credential. The agent holds a Cashu token; presenting (or spending) it grants the service; no account, no identity, no per-call invoice round-trip. This is the Routstr pattern — the token is the API key — and it is the lightest-weight, most private way for an agent to pay for a service.
• NWC (Nostr Wallet Connect). Lets an agent control a wallet to make these payments without holding the wallet’s keys directly — the permissioning layer behind autonomous service payment.

All three are permissionless at the payment layer: the service operator runs whatever access policy it likes, but no intermediary stands between the agent’s sats and the payment.

What’s for sale

The categories of service an agent consumes, roughly in order of how deployed they are today:

• AI inference — pay-per-query access to LLM and other model APIs (the most mature category; see Routstr and PPQ.AI below).
• Compute — task execution, rendering, training cycles billed per use.
• Data — feeds, datasets, real-time signals, paid lookups.
• API calls — any metered service behind an L402 paywall.
• Storage and infrastructure — paid, metered, machine-accessible.
• Other agents’ work (A2A) — the frontier: an agent subcontracting a task to another agent and settling in Bitcoin. This is the category that turns a collection of tools into an economy.

Agents as providers

The marketplace is two-sided, and the sell side is underbuilt relative to the buy side — which makes it an opportunity. An agent that can offer a service for Bitcoin needs three things: a way to gate the service on payment (an L402 paywall via Aperture, or a Cashu-token check), a way to be discovered (Nostr-based discovery is the deployed pattern — it is how Routstr’s providers are found), and a payout path to its treasury (covered in The Marketplace overview and Exchange). An agent that both consumes upstream services and sells its own output is a full economic participant — and the same payment mechanisms work in both directions.

Featured services (curated)

A few vetted, deployed venues an agent can use today — the proof that this layer is real, not hypothetical. (The full, categorized, community-rated set lives in the directory below.)

• OpenAgents — a Bitcoin-native marketplace for machine work: sovereign agents hold Nostr identities and self-custodial Lightning wallets, sell spare compute via the Pylon node / Autopilot app, and are paid in Bitcoin over Lightning, across five interlocking markets (Compute, Data, Labor, Liquidity, Risk). The closest existing model for this section’s full-directory shape; a clean Bitcoin-substrate fit.
• Routstr — a Bitcoin-powered AI-inference marketplace: a payment-gated reverse proxy in front of OpenAI-compatible LLM APIs, paid per request in Cashu ecash (the token is the API key), settling over Lightning, with Nostr-based provider discovery. The clearest deployed instance of an agent buying a service on the Bitcoin stack; HRF Top-15 Freedom Tech Project of 2025.
• PPQ.AI — pay-per-query access to AI models over Lightning / L402; an agent (or a human) pays per call with no subscription or account. A live A2A-adjacent proof-point.

Each links to its card in this section’s Services collection — the same tile-and-page format as the Stack’s Tools and the Exchange directory. The full categorized, community-rated set lives in the separate directory site below.

Off-the-shelf services an agent can pay for (curated)

Beyond agent-to-agent venues, an agent often needs ordinary real-world services — privacy, compute, hosting, domains, storage. The honest constraint for an autonomous agent is automatability: most merchants that “accept Bitcoin” actually bounce you to a human checkout (a CoinGate or BitPay page, or an account top-up), which an agent can’t drive on its own. Two stand out because an agent can genuinely pay itself:

• Mullvad VPN — a privacy VPN paid over Lightning against a random account number, with no email and no KYC. The cleanest direct-merchant fit on the consume side, and a model for what “a service an agent can pay for itself” looks like.
• Bitrefill — the bridge. A Lightning-native gift-card and top-up service with a real payment API (Thor) and no KYC. For the long tail of services that don’t take Bitcoin directly — domains, cloud, storage, mainstream brands — an agent buys a Bitrefill credit with sats and redeems it there. This is how the consume side reaches the rest of the digital economy without leaving Bitcoin.

Many VPN, hosting, and domain brands do take Bitcoin — but via human checkout, not an agent-drivable API. For those, Bitrefill is the agent-automatable path.

The full directory (separate site — marketplace.bitcoineconomy.ai)

The curated entries above are deliberately few. The complete picture — a categorized, user-rated directory of every service an agent can consume or offer for Bitcoin — is a different kind of thing from a static essay: it is interactive, data-maintained, and grows continuously, with community ratings to address the one risk a payment rail can’t (below). So it lives as its own sibling site at marketplace.bitcoineconomy.ai, which this section links out to, rather than as a page here. Treat it as a later v2 build; the on-site curated set ships first. Prior art shaping it: OpenAgents (its five-market structure is the closest live model), Routstr, PPQ.AI.

The honest caveat: a sovereign rail is not a guarantee of delivery

Paying for a service over Bitcoin makes the payment sovereign — no intermediary can block it, reverse it, or freeze it. It does not make the counterparty trustworthy. The service can be slow, wrong, down, or fraudulent; the model behind a pay-per-query API can be worse than advertised; an agent-provider can take payment and underdeliver. The permissionless rail that removes the payment intermediary also removes the chargeback and the dispute desk. This is the real risk of the Services layer, and it is exactly what a community-rating directory exists to mitigate — reputation as the substitute for an intermediary’s recourse. An agent operating here needs reputation signals, bounded per-transaction exposure, and ideally escrow or streaming-payment patterns for larger engagements. The rail is sovereign; the counterparty’s performance is earned, not guaranteed.