Beep is an agentic payments and treasury platform for autonomous agents and developer APIs. We provide a zero-fee protocol and SDKs that enable per-call micropayments, verification receipts, and instant settlement across agent-to-agent (A2A) commerce. Built on the Sui blockchain, Beep powers AI monetization, marketplaces, and an agentic treasury that shares on-chain yield back to builders (APY is strategy- and market-dependent; returns are not guaranteed).

What we do

Beep removes the friction and cost of charging per request, per token, or per API call. Using our a402 (HTTP-402) standard and developer SDKs, any tool, workflow, or model endpoint can issue a 402 challenge, accept stablecoin payment, verify a signed receipt, and release output—end-to-end in milliseconds. Funds settle to non-custodial treasuries, where balances can earn yield; merchants can offset processing to “zero-fee” via yield-share.

How it works

a402 protocol — An identity-aware, chain-agnostic extension of HTTP-402 that standardizes the challenge → pay → verify loop, including retries, idempotency, and cryptographic receipts suitable for audit and dispute review.

SDKs & middleware — Drop-in libraries for Node (and expanding) that wrap frameworks like Express/Fastify/Next and orchestration tools (LangChain, MCP servers) so teams meter endpoints without rewiring their stack.

Agentic treasury — Non-custodial vaults per developer/merchant with real-time yield streaming, analytics, reconciliation, and payouts.

Sui-first — We leverage Sui’s object-centric, high-throughput architecture for low-latency micro-flows, while keeping protocol design chain-agnostic.

a402 vs x402 (short blurbs)

Beyond EVM (true interoperability): x402 centers on EVM stablecoins. a402 is designed to be blockchain-agnostic from day one—supporting next-gen non-EVM chains like Sui (first), plus a path to Solana/Polkadot and even interoperability with non-chain rails (e.g., Interledger/FedNow bridges). Payment requests are abstracted from the settlement layer to minimize friction across systems.

Built-in auth & identity: x402 pairs with external auth (e.g., EVMAuth). a402 integrates authorization into the payment flow with attenuated, revocable capabilities (Macaroon-style semantics), so a single verified payment can grant scoped, time-bound access to specific API endpoints—ideal for autonomous agents.

Micropayment scale via channels: On-chain settlement for every tiny payment can bottleneck at high frequency. a402 natively supports off-chain/multi-channel sessions to aggregate countless micro-events into a single on-chain close—“single-fee” economics tailored to streaming data, per-token billing, and ultra-high-frequency agent workloads.

Reputation and trust layer: x402 is intentionally “dumb” (payments only). a402 adds optional, decentralized reputation primitives so agents and services can emit signed ratings/receipts, enabling reliability scoring and safer marketplace routing over time.

Agent-native from launch: a402 ships with first-class support for A2A, MCP (tools), orchestration frameworks (workflows), and OpenAI Agent/Responses/Assistants patterns—so any developer can adopt immediately, not just those on a specific stack. As agent economies scale to trillions of micro-transactions, a402’s channelized design and Sui-class throughput avoid EVM congestion limits.

Who we serve

AI & API developers: Monetize endpoints with pay-per-call or hybrid subscription + micropayments, priced per token, request, or minute.

Marketplaces & platforms: Dual-hop settlement (platform → provider) with instant rev-share and verifiable receipts.

Enterprises: Meter internal tools, enforce budget controls, and get audit-ready usage records for LLM/agent workloads.

Why it’s different

Zero-fee economics: Yield-share can neutralize merchant processing costs.

Agent-first design: Per-call, streaming, and micro-entitlements are first-class.

Verifiable receipts: Cryptographic proofs + transparent logs for reconciliation and disputes.

Developer-fast: Simple primitives—challenge(), pay(), verify()—and copy-paste examples get you live in minutes.

Primary use cases

Pay-gated MCP tools/plugins (per-tool, per-run)

AI API monetization (LLM calls, embeddings, RAG queries)

Agent marketplaces (instant creator payouts, rev-share)

Streaming/micro-entitlements (per message/token/minute)

Business model

Value-add services around the zero-fee core: optional share of treasury yield, enterprise support/SLA tiers, premium analytics/compliance modules, and marketplace facilitation.

Trust & compliance

Beep is non-custodial by design. On/off-ramp, KYC/AML, and chain attestations are delivered via partners. Yield varies with market conditions and smart-contract risk; no returns are guaranteed (any APY figures are targets, not promises). Teams can opt out of yield and still use Beep for instant A2A settlement.

Mission

Make machine-speed commerce native to the AI economy—so agents can think, act, and pay in real time, and developers capture value at the exact moment their software creates it.