Agent Payments Watch / Applications

In Brief

BitPlan developer Luke Rohenaz has launched BitPlan Gateway, a multi-model AI inference service that lets users and software agents access models from multiple providers while paying for usage in BSV through HTTP 402.

The gateway combines a browser playground, Model Context Protocol access and an OpenAI-style API behind a BRC-100 wallet-based identity and payment layer. Rather than requiring a conventional account and separately managed API credential, the service can use the wallet’s public key as the account identity and fund individual inference calls from the wallet or a prepaid credit balance.

The launch extends a pattern BSV TIMES has been following around machine-payable services: AI software is moving from merely receiving access to pre-provisioned APIs toward being able to encounter, purchase and consume computation as part of its own workflow.

News Report

BitPlan has launched a new AI inference gateway that places BSV payment directly between coding agents and a broad range of external AI models.

The service, available through gateway.bitplan.dev, presents itself around a simple model: inference is requested through a familiar software interface, the request is priced, and payment can be made in BSV without requiring the user to establish a conventional billing account with each underlying model provider.

The live gateway says there is “no account to create” and “no API key to manage” for its normal wallet-based flow. Instead, a BRC-100 wallet provides the identity associated with the service, while inference calls can be paid individually from that wallet or drawn from credits held by the gateway.

The result is not a new AI model.

It is an access and payment layer across many of them.

Multiple Models Behind One Gateway

BitPlan Gateway currently exposes models from multiple AI providers through a common interface.

The public site highlights offerings spanning Anthropic, OpenAI, Google, xAI, DeepSeek, Moonshot AI, Meta, Alibaba, Mistral, Z.ai and MiniMax, together with image-generation models. The gateway publishes model pricing in BSV, satoshis and U.S. dollar terms, based on the underlying providers’ token pricing.

Rohenaz’s launch announcement also specifically points to Jev, the newly released model from TypeSafe AI.

Jev is unusual because it is not designed primarily to produce conversational text. TypeSafe describes it as its first “System One Model,” built to take unstructured state and return typed probabilistic decisions that software can use directly. TypeSafe publicly introduced Jev this week following two years of development in stealth.

Its appearance through BitPlan Gateway is therefore a useful example of what a multi-model gateway can provide.

An application does not have to be rebuilt around a new commercial relationship every time another model becomes useful. The gateway can provide one access layer while the model behind a particular request changes.

Wallet as Account

The payment architecture is one of the more distinctive parts of the launch.

BitPlan Gateway states directly that the user’s wallet public key functions as the account identity.

That removes one of the familiar pieces of AI API infrastructure: the separately created service account associated with a conventional API key and stored payment method.

For an ordinary user, the gateway can be accessed through its browser playground after connecting a BRC-100-compatible wallet.

For software agents, BitPlan provides an MCP endpoint and an OpenAI-style API. The gateway lists integrations or setup paths for environments including Claude Code, Codex, Cursor, OpenCode, Cline, Grok Build, Gemini CLI, Windsurf, Copilot and Zed.

The site describes the agent-side payment mechanism as automatically signing the gateway token and paying an HTTP 402 request from the connected wallet when payment is required.

That matters because the payment can remain inside the software interaction.

The agent does not have to stop, direct a person to a checkout page, wait for a subscription to be created and then resume its task.

Instead, access to the computational resource and payment for that resource can form part of the same machine workflow.

HTTP 402 as the Purchase Boundary

HTTP status code 402 — Payment Required — has increasingly become a coordination point for machine-payable internet services.

The general pattern is straightforward.

A client requests a resource. The server indicates that payment is required and supplies the payment requirements. The client authorizes the requested payment and resubmits the request with payment information. Once the payment has been verified or settled, the service returns the requested resource.

The x402 specification formalizes this broader model and is designed to separate the internet transport, payment scheme and underlying payment network so that different implementations can support different combinations.

BitPlan Gateway applies the HTTP 402 concept to BSV-paid inference.

The distinction is worth keeping precise.

The gateway labels its service x402 · BSV, but the existence of this implementation should not by itself be read as confirmation that BSV has been incorporated into every upstream x402 Foundation SDK or reference implementation. The x402 specification is intentionally network-extensible, while individual clients, servers and facilitators still have to implement support for particular network and payment-scheme combinations.

What BitPlan demonstrates directly is the operational result: an agent can encounter a charge for model inference, have that charge handled through its BSV payment environment and receive the model output.

Live Calls Show the Payment Flow Operating

The gateway does more than describe the architecture.

Its launch page publishes example sessions from Claude Code, Codex and Grok Build using the same gateway to request inference from Muse Spark 1.3.

In one Claude Code example, a call consumed 74 input tokens and 1,069 output tokens, including 1,020 reasoning tokens. The gateway recorded a settled charge of 67,408 satoshis.

A Codex example performing a similar repository-summary task settled at 52,992 satoshis, while the Grok Build example settled at 38,369 satoshis after using 73 input tokens and 617 output tokens, including 563 reasoning tokens.

Those figures should not be interpreted as a direct efficiency comparison among the coding environments because the actual token consumption and execution paths differed.

What they demonstrate more usefully is metering.

The agent requests inference, the model consumes a measurable quantity of computation, the gateway calculates the resulting charge, payment is settled and the remaining balance is updated.

The purchase is therefore associated with the individual computational event rather than only with a monthly subscription.

MCP and Familiar API Access

BitPlan has also avoided making the payment system its own isolated developer interface.

The service exposes a Model Context Protocol endpoint for agent environments while providing an OpenAI-style API for applications already built around the increasingly familiar chat-completion interface.

The gateway describes its MCP endpoint as providing tools for model discovery, chat, image generation and credits, while handling the HTTP 402 payment when a call requires funding.

That approach reduces the amount of BSV-specific logic an application developer has to place in the actual AI task.

The application can continue thinking in terms of models and inference.

The payment layer sits underneath that interaction.

BitPlan also allows developers to bring their own provider API credentials, which can reduce the gateway charge while retaining the common interface. That makes the service partly a payment gateway and partly a model-routing layer rather than requiring every request to use BitPlan-provisioned provider access.

A Different Development From BitPlan’s First Launch

The Gateway also expands BitPlan beyond the application BSV TIMES covered in August.

BitPlan originally launched as a system for creating encrypted, versioned planning documents for AI and agent workflows. Its BRC-100 wallet handles encryption and publishing while encrypted plans can ultimately be stored as versioned 1Sat Ordinal inscriptions on BSV Blockchain.

That application is fundamentally about preserving information produced by agents.

BitPlan Gateway addresses another requirement of those same agents: acquiring computation.

The two functions are distinct.

One gives an agent-controlled workflow a way to preserve and share private working material.

The other gives software a way to purchase access to external intelligence.

Together, however, they point toward a broader architecture in which a wallet can become more than a place for holding a fee-token. It can provide identity, authorization, encryption and payment capabilities to software operating across multiple services.

A Step Beyond the Earlier BSVKey Inference Model

The launch also follows BSVKey’s recent work on BSV-paid AI inference.

BSV TIMES reported on September 8 that BSVKey’s Inference MCP had entered the official MCP Registry, giving agents access to Claude and Grok through both prepaid channels and a per-request HTTP 402 payment mode.

The two developments therefore overlap in an important area: both demonstrate that an AI agent can consume model inference while BSV handles the payment underneath the service request.

Their emphasis is different.

BSVKey demonstrated the machine-payment boundary particularly clearly through a dedicated inference MCP and an independently fundable HTTP 402 call.

BitPlan Gateway broadens the concept into a general model-access layer: many model providers, an MCP interface, an OpenAI-compatible API, a browser playground and wallet-backed service identity under one gateway.

That makes the latest development less about proving that one AI call can be purchased with BSV and more about whether BSV can sit underneath an ordinary multi-provider market for machine computation.

BSV TIMES Read

The interesting part of BitPlan Gateway is not that another website accepts BSV for an AI service.

The architecture moves the payment farther into the software itself.

Today, most AI agents operate inside an economic environment that was prepared for them by a person.

Someone creates the provider account. Someone supplies a credit card. Someone generates an API key. Someone chooses a subscription or establishes a spending balance. The agent then consumes what has already been provisioned.

HTTP 402 allows a different boundary.

A piece of software can reach a resource and encounter a price at the point where the resource is needed.

If the software has an authorized payment capability, the purchase can occur as another step in the task.

BitPlan Gateway gives that idea greater breadth by putting multiple AI providers behind the same payment and access layer.

This is particularly relevant for agents because the best model for one operation may not be the best model for another. A coding agent may use one model for reasoning, another for inexpensive classification, a specialized model for structured decisions and another for image generation.

Requiring a separate commercial relationship for every one of those services creates friction that humans can tolerate more easily than autonomous software.

A common gateway changes the abstraction.

To the agent, the question can increasingly become: what computation do I need, what does it cost, and am I authorized to buy it?

The BSV token then operates in a role that is straightforward but potentially important: a fee-token that software can use to obtain a service.

BitPlan Gateway is still a newly launched service, and the range of providers behind an aggregator should not be mistaken for direct partnerships or native BSV integration by those model companies.

But the working examples matter.

Claude Code, Codex and Grok Build are shown requesting metered inference through the same gateway, receiving a price and completing the call against a BSV-funded balance. The underlying model can change while the agent-facing payment relationship remains substantially the same.

That is a more mature form of the machine-payment idea BSV TIMES has been watching.

The payment is becoming less of an application feature.

It is becoming part of how software accesses other software.

Source Links

BitPlan Gateway — AI inference paid in BSV

BitPlan Gateway — Models

BitPlan — Encrypted, Versioned Agent Plans

TypeSafe AI — Introducing System One Models and Jev

x402 Foundation — Protocol Specification

BSV TIMES — BitPlan Launches Encrypted, Versioned Plan Documents on BSV Blockchain

BSV TIMES — BSVKey Inference MCP Listed in Official Registry With Pay-Per-Token BSV Settlement

Posted on September 17, 2026