Welcome to Fast
Build agent payments, x402 APIs, EVM funding, identity lookups, and file attestations with Fast SDKs and CLI tools.
Fast is the settlement and coordination layer for AI-native work. Agents, merchants, and services coordinate work, verify what was done, and settle the outcome programmatically, across both crypto and fiat rails.
Find the right Fast tool
Use the tool selection guide to match your task to a package: Fast-native payments, x402 API monetization, AllSet cross-network funding, Fast ID name resolution, or Fast Sign artifact attestations. For assistants and autonomous workflows, start with AI agent documentation access, including Markdown, the documentation index, and MCP retrieval.
The active SDK and API references describe current integrations. Sections labeled Archived preserve historical material; do not use them as current installation instructions or deployment guarantees. Check the linked source package for the version you install.
The Fast CLI and agent skill provide an operator-facing path for common account and payment tasks. Applications can instead compose the published SDK packages directly. These are distinct interfaces: neither removes the need to handle signing authority, network selection, and uncertain transaction outcomes.
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. Install the SDK, create a signer, and submit payments with a single function call. See the Fast SDK on GitHub for installation and code examples.
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. Use the x402 middleware to protect routes and the x402 client to pay for resources — see the x402 packages in the Fast SDK repo for integration examples.
When to Use Fast
Fast settles any programmatic outcome. Today the documented path is payments:
Use Fast for programmatic payments, i.e., payments that block task execution or service response. 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 supports multiple settlement assets based on needs:
Fiat (where a provider route is available)
Hosted funding providers may offer fiat entry points, subject to their supported regions, identity checks, and availability. This is not the same settlement path as a Fast-native transfer.
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 units and programmable settlement. Cross-chain delivery still has separate confirmation and relay steps.
Example: Agent pays $0.01 USDC for a single API request.
Available funding and settlement routes depend on the network and integration. Consult the CLI funding commands and AllSet SDK before promising a particular fiat or cross-chain path.
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.
Moving money is the visible part. The harder problem underneath is coordinating work across agents and humans and verifying it before anything settles. Fast is built for the whole path, not just the payment at the end.
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.
Fast is designed for low-cost programmatic payments. Check the fee behavior of the specific network, token, SDK workflow, and external provider before relying on a particular minimum payment size.
Sub-second finality → Agents don't wait.
Fast-native transactions can settle quickly, but a client can still observe a pending or unknown submission. Cross-chain movements have additional source and destination steps. Persist transaction identities and reconcile uncertain outcomes before retrying.
Mathematical verification → When settling $1B/day, every tx is provably correct.
The protocol's formal work concerns specified safety properties under stated assumptions. It does not prove that an arbitrary application, bridge configuration, or external payment provider is free of errors. See FastSet Protocol and the whitepaper for the scope of those claims.
How Fast Works
Fast has several layers. Most developers only touch the first and the second.
Published packages
The Fast SDK monorepo contains the CLI, core SDK, AllSet SDK, x402 packages, and the Fast ID and Fast Sign SDKs. Install the package needed for your workflow; check its package README and npm for the current release and compatibility requirements. A historical release matrix is not a reliable compatibility guarantee across independently versioned packages.
1. Fast Skill
The agent skill operates the Fast CLI for supported workflows.
2. Fast CLI
A command-line tool for the Fast network — manage accounts, send the network's configured token, use supported funding routes, and pay x402-protected APIs. On mainnet the default send token is fastUSD; EVM USDC funding requires selecting USDC explicitly.
3. Fast SDK
TypeScript SDK for the Fast network. Provides a high-level API for signing transactions, querying the network, and converting addresses and amounts.
4. AllSet Layer
AllSet is the interchange layer wrapped around by the Fast Skill 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. Fast Skill handles this automatically — developers do not need to interact with AllSet directly.
5. Fast Network
Fast Network is the underlying settlement network. The SDK and CLI interact with it through the proxy; advanced integrations may also use the documented REST or JSON-RPC surfaces. Network finality should not be confused with completion of an AllSet or hosted-provider workflow.
Start Building
Walk through the following materials to learn how to build with Fast step by step.
Current commands and examples
Fast Skill's complete SDK documentation
Frequently Asked Questions about Fast