Skip to main content
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

ComponentDescription
Machine Agent pairingBind 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 policyPer-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 catalogueCurated 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 searchPOST /market/search takes machine context, requirements, region, budget, and execution preferences and returns ranked MarketQuotes with reasons.
Market ordersPOST /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 escrowpayment-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 endpointsPOST /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 disputePOST /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 proofDID-controller challenge and EIP-191 signature flow that ties orchestration writes to the on-chain machine identity.

​
How it works

  1. Activate the machine. Run Activate to , , smart account, and post the bond. Pairing requires an active, bonded machine.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. Settle payment. POST /market/orders/:orderId/payment-intent mints a payment record on the chosen rail. For wallet-based and x402 rails, submit POST /payment-proof after the transfer (EVM proofs are RPC-verified against the ERC-20 Transfer log). For rails, call POST /payment/escrow-lock with the on-chain lock transaction. Once funds clear, the order moves to ready.
  8. 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.
  9. 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:
RailWhere it shows up
x402agentic.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.
mppSolana micro-payment protocol. Used by some pay.sh services on Solana.
vault-stripe / externalCard-mediated or external handoff.
wallet / wdk-usdt-transferDirect USDT transfer on peaq (default token USDT, decimals from PEAQOS_USDT_DECIMALS).
onchain-escrow / escrowFunds locked into a service-specified escrow contract via payment/escrow-lock.
not-requiredFree or pre-authorised services. Order proceeds straight to ready.
offchain-recordOff-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.

​
Launch partners

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.

​
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.