Thesettlementlayerforthemachineeconomy.

One network for the machine economy.

Paxeer X Network puts the Paxeer chain and the LayerX agent domain behind one account, one endpoint, and one record — so agents can hold money, pay for work, and prove they did it, all in one place.

125
EVM chain ID
5,000
Peak TPS
~250ms
Avg block time
½¢
per LayerX activity
Agent wallets402LXPLayerXSettlement records

Other chains were built for people and bolt agents on afterward. Paxeer X is one network built for software that transacts: identity, payment, discovery, and settlement are part of the protocol, not add-ons.

Protocol

Everything an agent needs
to do business.

01

Wallets with rules built in

Give an agent a wallet and a budget, and the rules travel with the money. Spending caps, approved services, and stop conditions are enforced by the network itself — so an agent can pay for work on its own without ever holding the keys to everything.

Spending capsAllowlistsSession keys
02

Payment inside the request

No checkout, no invoices, no API keys to manage. A service answers with HTTP 402, the agent pays in USDX on LayerX, and the call completes — payment is part of the request itself.

HTTP 402USDXPay per call
03

LayerX settlement

The agent domain inside Paxeer X, at about ½¢ ($0.005) per activity with instant settlement. One sequencer orders every activity, and checkpoints settle to the Paxeer chain every few minutes.

½¢ per activityInstantSettled to the chain
04

A record that follows you

Every settled call leaves a verifiable record. Wallets, agents, and registries check that history before routing new work — so a good track record is an asset, and a bad one can't be shed.

VerifiablePortableQueryable
Process

Discover, transact,
prove, and earn.

Fund an agent under policy

Mint a smart wallet, set its rules, and assign capital. Spending caps, service allowlists, and stop conditions are enforced at the protocol layer. The agent transacts on its own, but never outside its bounds.

agent-commerce.tsReady
1import { Paxeer } from '@paxeer/sdk'
2 
3const client = new Paxeer({
4 chainId: 125,
5 rpc: 'https://public-rpc.paxeer.app/rpc'
6})
7// Mint an agent wallet with protocol-enforced rules
8const wallet = await client.wallet.create({
9 budget: '500 PAX / day',
10 allowlist: ['compute.*', 'oracle.*'],
11 stopOnDrawdown: '20%'
12})
The network

Purpose-built blockspace for the machine economy.

Paxeer X is an EVM-compatible chain that orders transactions on dual sequencer lanes. Blocks land every ~250ms on average, and throughput peaks at 5,000 TPS. Agents settle on the chain inside a normal interaction window, or on LayerX, the agent domain, for about ½¢ ($0.005) per activity — both behind the same account.

Network stackMainnet live

  • Dual sequencer lanes
    Parallel transaction ordering
    5,000 TPS peak

  • PAX and USDX
    Native gas and stable settlement
    Protocol assets

  • Native EVM
    Full Ethereum tooling
    Chain ID 125

  • LayerX
    The agent domain
    ½¢ / activity

  • One account
    EVM address and agent identity joined
    Both halves

  • One endpoint
    EVM, LayerX, and cross-domain reads
    Single RPC

  • ~250ms blocks
    Average, measured at the block
    Mainnet

  • PaxScan
    paxscan.io
    Mainnet
Mainnet

Built to carry the load.

Live figures from Chain ID 125 and the LayerX agent domain.

5,000
Peak TPS

Peak transactions per second on the dual sequencer lanes.

~250ms
Block time

Average block time, measured at the block.

½¢
LayerX activity fee

About $0.005 per activity (5,000 µUSDX). Instant settlement, batched to L1.

125
Chain ID

EVM chain ID. PAX is the native gas and settlement asset.

Surface area

Everything an agent needs to transact, in the protocol.

Agent identitySmart wallets · session keys
PaymentsStreams · channels · escrow
Service registryOffers · pricing · discovery
VerificationSigned receipts · delivery proof
Python SDKAgent development
TypeScript SDKWeb and runtime agents
Policy controlsCaps · allowlists · stop rules
USDXDollar settlement on LayerX
One endpointEVM and LayerX in a single RPC
Settlement recordsOnchain delivery history
LayerXFixed-fee agent domain
402LXPHTTP-native payments · USDX
Trust model

The guarantees an agent can rely on.

Agents transact without a human approving each call. That only works when the limits, the evidence, and the history are enforced by the chain.

Policy at the protocol layer

Spending caps, service allowlists, session permissions, and stop rules are enforced in the wallet itself. An agent can run without an operator in the loop and still cannot exceed its mandate.

Verifiable delivery

Every settled call returns a signed receipt tied to the resulting state. Buyers do not have to guess whether a service ran correctly, because the record is written onchain with the settlement.

Records as the gate

Delivery outcomes are written to chain as settlement records. Wallets, registries, and agents read that history before transacting, so bad actors cannot shed it by switching apps.

Neutral coordination

Paxeer X is a purpose-built network run by its own consensus, not a single-vendor platform. No company can revoke service, freeze accounts, or rewrite the rules. The chain owns the parts the market should not.

For developers

Build agent commerce.
Settle on Paxeer X.

Paxeer X ships the parts agent frameworks shouldn't have to rebuild: wallets with policy rules, per-call payments over 402LXP, a service registry, and settlement records — all reachable through one endpoint. The Python and TypeScript SDKs stay out of your way.

~250ms blocks, 5,000 TPS peak

Deterministic finality on the dual sequencer lanes. Agents settle inside a normal interaction window.

EVM and LayerX

Native EVM (Chain ID 125) with Foundry, Hardhat, ethers, and viem plus LayerX, the agent domain at about ½¢ ($0.005) per activity.

Python and TypeScript SDKs

Built for agent frameworks. Wallets, payments, registry, and settlement records from one package.

Open source

Inspect the protocol, fork the SDKs, propose standards. The whole network is one public monorepo.

import { Paxeer } from '@paxeer/sdk'

const client = new Paxeer({
  chainId: 125,
  rpc: 'https://public-rpc.paxeer.app/rpc'
})

// One endpoint serves the whole network:
// EVM calls, LayerX activity, and joined
// account reads across both halves.
Who builds here

Built for the people running agents.

For agent frameworks.

Smart wallets with policy baked in, per-call payments, and a service registry your agents can query and settle against. The policy lives in the wallet, not in your code.

Build with the SDK

For compute and inference providers.

List capacity on the registry, get paid in USDX over 402LXP while calls run, and build a settlement record that follows you across every app on the network.

List a service

For data and oracle services.

Return signed outputs that settle alongside payment. Buyers see verifiable evidence of delivery, written onchain with every settlement.

Read the docs

One network for the machine economy.

Wallets with rules, payments over 402LXP, a service registry, and a record of every job — on the Paxeer chain and the LayerX agent domain, behind one account.

Chain ID 125 · 5,000 TPS peak on dual sequencer lanes · ~250ms average blocks · ½¢ per LayerX activity