Welcome to Fast

Fast is payment infrastructure for programmatic transactions. It enables agents, APIs, merchants, and services to request, authorize, send, and settle payments — fully programmatically, across both crypto and fiat rails.

Who Fast Is For

AI and Automation Developers

You build AI agents, autonomous workflows, or multi-agent systems. Your agents need to pay for resources — data, compute, storage, other agents' services — and receive payment for their own work. All of this must happen programmatically, without a human approving each transaction.

With Fast, every agent has a wallet. Agents pay each other directly. Balances update in real time. An agent can earn, spend, and manage its finances autonomously.

// Agent pays for compute, receives result
await f.send({ to: computeAgent, amount: '0.10' });
const output = await requestCompute(task);
// Agent checks its earnings
const { amount } = await f.balance();

API Developers

You build APIs, services, or SaaS products. You want to monetize them with usage-based pricing — per request, per inference, per compute step, per action — without the overhead of subscriptions, API key management, billing systems, or invoice reconciliation.

With Fast, your API charges the caller at the moment of use. Payment is part of the request-response cycle. No billing infrastructure required.

// Seller charges $0.01 per request — returns HTTP-402 Payment Required if unpaid
app.use(paymentMiddleware(myAddress, { 'GET /api/*': { price: '$0.01', network: 'fast' } }, facilitator));
// Buyer handles the 402, signs payment, and retries — automatically
const { body } = await x402Pay({ url: 'https://api.seller.com/api/data', wallet });

Why Fast And Why Now

As software systems increasingly perform economic activity — calling APIs, coordinating services, purchasing compute — payments must become part of the execution flow of software, not a manual step outside it. However, none of the current payment infrastructure is ready. Traditional payment rails require human authorization and batch in hours. Crypto payment systems offer programmability but cannot settle in fiat. Neither was built for machine-initiated transactions at scale.

Fast's payment infrastructure is powered by a purpose-built settlement network engineered specifically for high-frequency programmatic payments. Three properties make this viable:

Near-zero fees → Micropayments work.

An agent can pay $0.001 per API call, $0.01 per inference, or $0.50 per task without transaction fees consuming the payment. This is what makes pay-per-request pricing viable for APIs and pay-per-action economics viable for agents.

Sub-second finality → Agents don't wait.

Payments settle in under one second and are immediately final — no pending states, no confirmation delays, no rollbacks. An agent does not wait. A workflow does not poll. The payment settles, the balance updates, and execution continues.

Mathematical verification → When settling $1B/day, every tx is provably correct.

Every transaction is provably correct. When infrastructure settles billions of dollars per day across millions of autonomous agents, correctness is not a feature. It is a requirement.

Developers on Fast never sees any of this because the Fast offers a complete set of SDKs that handle all settlement, signing, and network interaction internally. From the developer's perspective, sending a payment is a function call that returns a receipt.

---

When to Use Fast

Use Fast when payment must occur before a task executes or a service responds.

Common scenarios include:

• An API charging $0.01 per request

• An agent paying another agent for a task

• A service charging per compute, inference, or workflow step

• An application charging per action instead of subscriptions

• A merchant accepting payment from a software client or automated agent

These patterns commonly appear in systems such as:

• Pay-per-use APIs — monetize endpoints with per-request pricing

• Agent marketplaces — agents discover, negotiate, and pay for services

• Automated service payments — workflows pay for compute, data, or storage

• Machine-to-machine commerce — software systems transact with each other and with merchants

Fast is designed for programmatic payments, where software determines when payment is requested and when execution continues.

---

Settlement Options

Fast supports multiple settlement assets depending on the payment flow.

Fiat

Supported fiat rails allow software systems to transact with real-world businesses and traditional services — without requiring the counterparty to hold or understand crypto.

Example: Agent pays $5 USD to complete a booking or purchase.

Stablecoins

Stablecoins are commonly used for digital services and micropayments because they provide predictable pricing with instant, programmable settlement.

Example: Agent pays $0.01 USDC for a single API request.

Fast handles both settlement paths. Developers choose the settlement asset when creating a payment request — the payment lifecycle, authorization flow, and developer experience remain identical regardless of whether settlement occurs in stablecoins or fiat.

---

How Fast Works

Fast has three layers. Most developers only touch the first.

1. Fast Gateway → All that matters to Devs.

The Fast Gateway is the developer-facing interface that has access to a complete set of carefully designed and easy-to-use SDKs. Install it, create a wallet, send payments right away. Fast Gateway is a complete payment stack that handles key management, transaction signing, serialization, and network communication.

2. AllSet Layer

AllSet is the interchange layer wrapped around by the Fast Gateway that connects Fast to both fiat and cryptos. AllSet enables agents to receive funds from any supported network and withdraw to any supported settlement destination. The Fast Gateway handles this automatically — developers do not need to interact with AllSet directly.

3. Fast Network

Fast Network is the underlying settlement network that powers the Fast Gateway. It enables massively parallel transaction processing and settlement, with no blocks, no consensus, and no validator-to-validator communication. This is what delivers sub-second finality, near-zero fees, and mathematically verified correctness. Developers never interact with this layer — it is the engine inside the car.

---

Start Building

Walk through the following materials to learn how to build with Fast Gateway step by step.

SDK References	Fast Gateway's complete SDK documentation
Advanced Topics	FastSet protocol, JSON-RPC API, AllSet Layer
FAQ	Frequently Asked Questions about Fast