Services

The 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 live 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 Treasury 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, liveness-probed set lives in the directory below.)

• OpenAgents — an open marketplace for machine work where you ask for an outcome and agents and human operators produce it with verifiable evidence, settled in Bitcoin over Lightning. Its flagship Khala is a live OpenAI-compatible inference gateway (openagents/khala, billed per call in sats) an agent can call directly, alongside contributor Pylon nodes (self-custodial Lightning wallets) and a Bitcoin-paid training run — 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.
• Maple AI — private inference: every prompt runs inside a TEE with end-to-end encryption, provably unreadable to the provider, behind an OpenAI-compatible API (Maple Proxy). Subscription-based, Bitcoin accepted (yearly plans, 10% discount) — the operator funds the account and the agent drives the API. The privacy-axis counterpart to the sats-per-call venues above.

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 set lives in the separate live 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. These stand out because an agent can genuinely pay itself — across privacy, compute, and the long-tail bridge:

• 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.
• LNVPS — compute, the agent-native way. A Lightning VPS with Nostr login, no KYC, fundable over NWC, provisionable by API — an agent can stand up its own server (even a child agent) and pay for it itself. The first deployed instance of an agent buying its own infrastructure ran on LNVPS (see Field-Notes).
• BitLaunch — mainstream compute (DigitalOcean/Vultr/Linode) with a real API + SDKs and Lightning-automated payments, no KYC — “programmable servers with programmable money” for an agent that wants big-cloud capacity paid in Bitcoin.
• Bitrefill — the bridge. A Lightning-native gift-card and top-up service with a purpose-built agent interface (a remote MCP server, alongside the raw Thor API) and no KYC. For the long tail of brands that don’t take Bitcoin directly, an agent buys a Bitrefill credit with sats and redeems it there — and its prepaid virtual Visa/Mastercard products extend the same bridge to anything that takes cards, including categories the catalog itself doesn’t carry. 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 (Vultr, for instance, routes crypto through a BitPay redirect). For raw compute, LNVPS and BitLaunch take Lightning directly; for everything else, Bitrefill is the agent-automatable path.

Liquidity & yield (curated)

Receiving payments over Lightning requires inbound liquidity — and acquiring or providing it is a marketplace activity, not something an agent runs locally (the software for that is Reflex in The Stack). These are the two sides of that market: an agent buys capacity so it can get paid, or sells idle bitcoin as routing liquidity to earn yield — both self-custodial, both API-drivable.

• Amboss (Magma) — the buy side: a public channel-liquidity marketplace where an agent purchases inbound capacity opened directly to its own node, sized in dollars and paid in sats, with no account on the buy path (and an MIT MCP server). The deployed answer to “how does an agent get paid over Lightning.”
• Amboss Rails — the sell side: put idle, self-custodied bitcoin to work as routing liquidity and earn yield from the payment flow that crosses it, driven by API.

The concept lives in The Stack (§ Liquidity management); these are the venues that transact it.

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

The curated entries above are deliberately few. The complete picture lives as its own sibling site at marketplace.bitcoineconomy.ai — and it’s live, not a promise. What it publishes today: a curated registry of services that clear one bar (an agent must be able to drive the service through a real API), the live announcement data from the public Nostr relays (provider and mint announcements, shown as announcements — not endorsements), endpoint liveness probes refreshed every six hours (announcements outlive their nodes; the directory knows which are actually alive, and how fast), and a cross-provider price index — hundreds of models, priced in sats per token, sorted cheapest-first. All of it is agent-readable by design: llms.txt opens with a five-fetch recipe, and the JSON routes are the product, not an export. Community ratings — the reputation layer that addresses the one risk a payment rail can’t (below) — are the directory’s next phase. 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 the directory’s reputation layer exists to mitigate — reputation as the substitute for an intermediary’s recourse. (Community ratings are the directory’s next phase; its trust signals today are probed liveness and announcement freshness.) 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.