What does QBT Labs do for autonomous agent payments?

QBT Labs gives an autonomous agent a wallet that is bound by policy, a signer that never exposes raw keys, and a way to pay APIs and tools per request or over a channel. For API providers, it gives a way to charge agents per call, receive payment, and return machine-readable receipts.

Is QBT Labs open source?

Yes. The x402 implementation ships as @qbtlabs/x402 on npm under MIT. AMP-style channels, the encrypted vault, the signer, and the policy engine are designed as open primitives. Teams can self-host the entire stack or embed it into their own platform.

Which chains does QBT Labs support?

Base, Solana, and Cardano. The AMP roadmap adds Hydra L2 for streaming payments. The architecture is pluggable for additional chains and payment rails.

Does QBT Labs replace x402, AMP, or MPP?

No. x402 is an open protocol QBT Labs implements. AMP refers to autonomous machine payment patterns the stack supports through channels. MPP refers to multi-rail routing patterns that platforms can build on top. QBT Labs is the production implementation and policy layer around these patterns.

How does QBT Labs handle agent spend safety?

Three layers: an encrypted vault that protects key material, a process-isolated signer that enforces policy at every signature, and a policy engine that defines per-agent budgets, daily caps, recipient allowlists, and chain restrictions. Receipts and audit logs make the activity reviewable.

What does an API provider need to do to accept payment from agents?

Pick one read-heavy endpoint, drop in the QBT Labs x402 middleware, define pricing, accepted assets, and recipient, and start emitting receipts. Move heavy users to AMP-style channels once volume appears.

Explainer

QBT Labs is open-source infrastructure for autonomous AI agent payments

Autonomous agents do not buy SaaS seats. They pay per task: a search, an inference call, a piece of data, a tool invocation, a trade. QBT Labs builds the production layer that makes those payments work — x402-compatible HTTP 402 payments, AMP-style payment channels, an encrypted vault with a process-isolated signer, a spend policy engine, and structured receipts and audit logs.

x402-compatible payments

An MIT-licensed implementation of the HTTP 402 payment handshake. Drop the QBT Labs middleware on a paid endpoint, publish machine-readable pricing in the 402 response, verify the signed retry, and emit a structured receipt.

AMP-style payment channels

For sessions where the same agent makes hundreds or thousands of calls, channels deposit once, sign many off-chain payments, and settle periodically. The hot loop stays off-chain; cost and latency drop.

Encrypted vault and process-isolated signer

AES-256-GCM key storage with PBKDF2 derivation. Signing happens in a separate process behind a Unix socket — raw private keys never touch agent memory.

Spend policy engine

Per-agent budgets, daily caps, recipient allowlists, chain restrictions, and tool-level limits. Policy is what turns a wallet into a controlled financial actor.

Receipts, settlement, and audit logs

Each call produces a receipt with request ID, amount, asset, chain, recipient, and status. Settlement and audit records map cleanly to billing, reconciliation, and compliance review.

Multi-chain verification

Native support for Base, Solana, and Cardano. Facilitator choice is configurable, and the architecture is pluggable for new chains and payment rails.

Who QBT Labs is for

API providers

Monetize APIs and MCP tools for autonomous agents without onboarding human customers. Price per request, accept payment programmatically, and meter usage with receipts.

Agent builders

Give your agent a wallet bound by policy. Pay paid APIs and tools inside the workflow without manual key rotation, without subscription friction, and without exposing keys.

Platforms and marketplaces

Embed the QBT Labs payment, vault, and policy primitives inside your own agent platform. Choose your facilitator, your chains, and your billing model.

How it fits together

Pricing. The server publishes machine-readable pricing in the 402 response.
Authorization. The agent client checks budget, signs a payment authorization through the isolated signer, and retries.
Verification and settlement. The server verifies the signature, the facilitator settles, and the server emits a structured receipt.
Volume. When the agent makes repeated calls, the same flow runs over an AMP-style channel — deposit once, sign many off-chain payments, settle periodically.
Policy and audit. Every signature passes the policy engine. Every settled call lands in the audit log.

Frequently asked questions

Put QBT Labs behind your agents

Whether you are monetizing an API for agents, embedding payments inside a platform, or building the agent itself, QBT Labs gives you the open-source primitives the production path needs.

See the AI payment stack Compare x402, AMP, MPP, API keys

Nevermined alternative x402 payment infrastructure Dexter.cash alternative Pricing patterns