Scale

Scale pairs an to an activated, machine and gives it delegated authority over the machine’s , bounded by spend limits and an allow/denylist. The agent discovers, buys, and consumes services through the Machine Markets API. The agent is provisioned outside peaq; pairing, policy, discovery, ordering, payment, and execution happen through peaqOS. It builds on the each machine receives at Activate and the credit signal from Qualify. The machine’s and carry through to providers when the agent buys.

What ships

Component	Description
Machine Agent pairing	Bind a third-party AI agent (Claude, OpenAI, Virtuals, Teneo, etc.) to a machine via a signed EIP-191 challenge. peaqOS verifies the signature, persists the agent’s identity and verification metadata, and issues a signed HS256 session JWT (`pairingToken`) the agent presents as `x-agent-pairing-token` on market writes. Tokens rotate via a sessions endpoint.
Delegation policy	Per-transaction limit, daily spend limit, currency, and allowed/denied skill keys and service IDs. Enforced server-side on every market call. Policy changes invalidate the session token’s `delegationPolicyHash`; rotate after a `PATCH`.
Skill registry and service catalogue	Curated capabilities (`oracle.price-feed`, `compute.marketplace`, `storage.object`, `data.location`, `identity.proof-of-person`, `device.control`, `machine.commerce`, `network.partner-console`) and the concrete provider services that fulfil them.
Market search	`POST /market/search` takes machine context, requirements, region, budget, and execution preferences and returns ranked `MarketQuote`s with reasons.
Market orders	`POST /market/orders` locks a service from a quote into an order with state machine `created → payment_pending → ready → executing → delivered → confirmed` (or `disputed` / `cancelled` / `failed` / `handoff`). Server-side policy and spend checks fire on create.
Payment intent and escrow	`payment-intent` selects a rail; `payment-proof` records or RPC-verifies on-chain payment; `payment/escrow-lock`, `payment/release`, `payment/refund` cover the escrow lifecycle. Solana proofs are recorded; EVM proofs verify via RPC against the ERC-20 Transfer log.
Execute and runtime endpoints	`POST /orders/:orderId/execute` materialises the order as a task plus route, dispatches to a native provider or a machine-side runtime endpoint registered via `PUT /machines/:machineId/runtime-endpoints/:providerKey` or heartbeated by an on-machine runtime agent, and writes a `Run` and `Outcome`.
Confirm and dispute	`POST /confirm` closes the order and releases escrow; `POST /dispute` opens a dispute record and freezes payment. Pairings with non-terminal orders cannot be revoked (`OPEN_MARKET_ORDERS`).
Machine identity proof	DID-controller challenge and EIP-191 signature flow that ties orchestration writes to the on-chain machine identity.

How it works

Activate the machine. Run Activate to , , smart account, and post the bond. Pairing requires an active, bonded machine.
Prove identity ownership. POST /machine-identity/challenges returns a message that the DID-controller key signs (). The signed proof is attached when the machine is registered with the orchestration service.
Provision a Machine Agent. Get an agent from any provider you trust: Claude, OpenAI, Virtuals, Teneo, your own runtime. peaq does not provide the agent.
Pair the agent. is -based.
1. POST /machines/:machineId/agent-pairings/challenges with the agent’s agentAddress, agentProvider, agentRole, and optional agentDid. The response is an AgentPairingChallenge with challengeId, message, and expiresAt.
2. The Machine Agent signs message (EIP-191 personal_sign) with the wallet key behind agentAddress.
3. POST /machines/:machineId/agent-pairings with agentProof: { challengeId, signature } and the delegation policy. The orchestrator verifies the signature, persists the pairing with verification metadata, and returns the AgentPairing with a signed session JWT in pairingToken. Store it client-side and send it as x-agent-pairing-token on market writes.
4. Tokens expire (default 1 hour). Rotate by issuing a fresh challenge and calling POST /machines/:machineId/agent-pairings/:pairingId/sessions with the new proof. Rotate after any PATCH to the delegation policy.
Search the market. The agent calls POST /market/search with machine context, service type, capabilities, region, budget, and optional providerCredentials. The orchestrator returns ranked MarketQuotes with reasons for each ranking.
Place an order. POST /market/orders with machineId, agentPairingId, serviceId, and optional searchId + quoteId creates an order (status created). The orchestrator enforces the and per-transaction and daily spend limits at create. The recommended is copied from the service into order.payment.
Settle payment. POST /market/orders/:orderId/payment-intent mints a payment record on the chosen rail. For wallet-based rails, submit POST /payment-proof after the transfer (EVM proofs are RPC-verified against the ERC-20 Transfer log). For the x402 rail there is no buyer transfer — the agent wallet signs the provider’s payment challenge and the signed header is the proof; the provider is paid during execute. For rails, call POST /payment/escrow-lock with the on-chain lock transaction. Once funds clear, the order moves to ready.
Execute. POST /market/orders/:orderId/execute materialises the order as a task plus route, dispatches to a native provider or a machine-side runtime endpoint, and writes a Run plus an Outcome. Successful runs land in delivered. External-handoff services return a structured handoff and land in handoff.
Confirm or dispute. POST /market/orders/:orderId/confirm closes the order and triggers payment/release for held funds. If the service did not deliver, POST /market/orders/:orderId/dispute opens a dispute and freezes payment until peaq resolves it.

Read-only shortcut

Free, read-only operations can skip the order flow entirely. POST /market/services/:serviceId/execute runs the operation directly with machineId, agentPairingId, operation, and optional input / providerCredentials. The orchestrator dispatches through the same task + route + run + outcome machinery as executeMarketOrder but does not create an order, payment intent, or escrow record. Paid, external-handoff, and state-changing operations still go through POST /market/orders.

Payment model

peaqOS does not collect marketplace payments. The payment-intent and payment-proof endpoints record provider/service payment state only when the selected adapter requires direct provider payment. Operators or machines pay the selected provider directly through that provider’s supported rail. Raw payment headers are never stored.

Payment rails

The orchestrator quotes services in the rail the provider supports. Active rails:

Rail	Where it shows up
`x402`	agentic.market services and most pay.sh services. Agent wallet responds to an HTTP 402 payment-required challenge; orchestrator replays the request with the agent’s payment headers via the `paidHttp` adapter.
`mpp`	Solana micro-payment protocol. Used by some pay.sh services on Solana.
`vault-stripe` / `external`	Card-mediated or external handoff.
`wallet` / `wdk-usdt-transfer`	Direct USDT transfer on peaq (default token `USDT`, decimals from `PEAQOS_USDT_DECIMALS`).
`onchain-escrow` / `escrow`	Funds locked into a service-specified escrow contract via `payment/escrow-lock`.
`not-required`	Free or pre-authorised services. Order proceeds straight to `ready`.
`offchain-record`	Off-chain attestation, recorded but not RPC-verified.

The orchestrator handles conversion when a service quotes in a chain or token the agent does not natively hold.

Service providers

At launch:

QVAC private inference (Tether strategic, co-announced).
The agentic.market suite over x402: Claude, ChatGPT, 2Captcha, Firecrawl, Wolfram|Alpha, Exa.
The pay.sh suite: Gemini, BigQuery, Document AI, StableUpload, Cloud Translation.

Added since launch:

Akash — decentralized compute.
GEODNET — RTK precision-positioning data.
Arcium — confidential compute.
Acurast — decentralized compute; its Deploy Agent runs as a native provider runtime in the orchestrator.
Naver Maps — mapping and geolocation APIs.

The live catalogue is on robotic.sh; query it programmatically via GET /market/services and market search.

Delegation policy

type DelegationPolicy = {
  allowedSkillKeys: string[];   // e.g. ["storage.object", "compute.marketplace"]
  deniedSkillKeys: string[];
  allowedServiceIds: string[];  // exact service IDs from /market/services
  deniedServiceIds: string[];
  perTransactionLimit?: number | null;
  dailySpendLimit?: number | null;
  currency?: string | null;     // ISO 4217 or token symbol
};

Policy is enforced server-side on every call. Update it at any time via PATCH /machines/:machineId/agent-pairings/:pairingId. Revoking a pairing (DELETE) terminates the agent’s delegated access immediately, unless the pairing has open market orders (OPEN_MARKET_ORDERS).

Multichain

peaqID, Machine NFT, and the stay canonical on peaq. Smart accounts and Machine NFTs deploy to supported chains (Agung and Base Sepolia at launch). Machine Agents pay across chains using the chain and token a service quotes in. A six-daemon Signer Daemon fleet watches finalized peaq and Agung events, packages them into EIP-712 batches, and pushes them to per-chain Lite contracts (DIDLite, IdentityLite, StakingLite). Read full architecture in the Omni-chain concept. See the roadmap for chain rollout.

Build with Scale

Machine Markets API

Base path, access model, error codes, and the full HTTP endpoint surface.

Machine Markets (concept)

How pairing, skills, services, orders, payments, and execution hang together.

peaqOS CLI: `scale`

peaqos scale agent pair, search, and the order family from your terminal.

SDK: orchestration namespace

client.orchestration for JS and Python.

Welcome

Get Started

Concepts

Functions

Guides

What ships

How it works

Read-only shortcut

Payment model

Payment rails

Service providers

Delegation policy

Multichain

Build with Scale

Machine Markets API

Machine Markets (concept)

peaqOS CLI: `scale`

SDK: orchestration namespace

​What ships

​How it works

​Read-only shortcut

​Payment model

​Payment rails

​Service providers

​Delegation policy

​Multichain

​Build with Scale

Machine Markets API

Machine Markets (concept)

peaqOS CLI: `scale`

SDK: orchestration namespace

​Related

What ships

How it works

Read-only shortcut

Payment model

Payment rails

Service providers

Delegation policy

Multichain

Build with Scale

Related