Features

Everything Paxeer X ships

75 features in five groups. Each page says what the feature does, who it's for, and how it works underneath.

Paxeer chain

The EVM chain at chain ID 125: consensus, execution, custody and the assets it holds.

Autobahn lane consensus with sharded sequencing

Consensus that splits data from agreement

Bonding-curve token launchpad

Launch a token that trades immediately

Checkpoint anchoring and challenges

Settle LayerX batches on the chain

Custody vault for LayerX funds

The chain holds the money

Exchange intents and margin

On-chain intents, matching in LayerX

Parallel block execution

Two schedulers run every block in parallel

PAX native asset

One asset for gas, staking and settlement

Paxeer EVM chain (chain ID 125)

An EVM base layer at chain ID 125

Proof-carrying withdrawals and forced exits

Exit with a proof, paid out once

Scheduled token release and epoch hooks

Issuance on a dated schedule, not a rate

Transaction admission, fees and gasless paths

Bounded gas prices and two fee-exempt classes

Validator oracle price feeds

Prices agreed by the validators who build blocks

LayerX agent domain

The agent domain inside the network: wallets, payments, receipts and the sequencer.

402LXP HTTP per-call payments

Charge for one HTTP call

Activity envelope, receipts and replay

One envelope, one receipt, one execution

Agent daemon with policy engine

Budget and gate every agent activity

Agent identity, rotation and recovery

Rotate agent keys without dropping work

Agent wallets and account namespaces

Typed subaccounts from readable account names

Asset registry and custody-backed assets

Atomic transfer sets

Every payment settles as one unit

Custody bridge and emergency exit

Deposits proven, withdrawals settled on chain

Escrow holds, capture and disputes

Pay on delivery, not up front

Fees and resource metering

Every activity costs 1/10 of a cent

LayerX session keys and grants

Give an agent less than your key

Payment streams, time-based and metered

Get paid as the work happens

Perpetual and spot markets

Trade perps and spot in the kernel

Receipt proofs and offline verification

Check a paid call without a node

Sequencer, batches and ordering

One order everyone can check

Service registry and work agreements

Sell agent work under agreed terms

Spend budgets with period caps

Cap agent spending where the funds live

Interface

What people and apps touch: one account, one endpoint, passkeys and statements.

Developer console and API keys

One key, visible scopes and quota

Explorer with a joined account page

One account page, four spellings

Human control plane for owners

Hold funds, move money, see settlement

Managed agent wallets and approval inbox

Cap what your agents can spend

Money journeys and cross-domain intent routing

State the movement, not the mechanism

Onboarding and team-allocated funding

One account across both domains

One account, both domains

One JSON-RPC endpoint for the network

One endpoint for the whole network

Passkey sessions and step-up approval

Passkeys hold your account, not passwords

px_* cross-domain read namespace

Eight reads across both domains

Statements, evidence exports and notifications

Your record, exportable and verifiable

Developers

SDKs, CLIs, RPC namespaces, local environments and the test harnesses.

Client SDKs in seven languages

Call the network from seven languages

Core protocol and verification CLIs

Run, control and verify nodes from a shell

Cosmos gRPC, REST and Swagger surface

Query the chain from Cosmos tooling

Documentation site and wiki

Docs that cite the code behind them

Explorer APIs and self-hosting stack

Query the explorer or run your own

Foundry and Hardhat contract toolchain

Foundry and Hardhat, already wired up

Hosted developer services

Faucet, webhooks, dashboard and program registry

LayerX developer CLI

One binary for wallets, payments and programs

Local development environment

Run the agent domain and chain locally

MCP, A2A and framework adapters

Give a model scoped tools, not authority

Node EVM JSON-RPC namespaces

Standard Ethereum JSON-RPC on chain ID 125

Payment middleware and framework integrations

Charge per request, not per checkout

Program SDKs and porting kits

Deterministic programs in three languages

Public JSON-RPC gateway and OpenRPC schema

One endpoint for chain and agent reads

Repo build system and developer tooling

One command set builds the whole network

Runnable samples and reference apps

Samples that cannot go stale

Test, conformance, load and benchmark runners

See exactly what Paxeer X exercises

Network

Running the network: node roles, finality, data availability, upgrades and governance.

Bonded guarantors with slashing

Bonded operators re-execute every batch

Cross-domain precompile connector

Verify LayerX evidence inside an EVM call

Data availability commitments and challenges

Prove the data behind a state root

Deterministic replay and divergence halts

Replicas halt instead of serving wrong state

Disposable beta cluster bring-up

Bring up the whole stack locally

External-chain connections

Reach Ethereum, Solana and IBC chains

Genesis, import, snapshots and migration

Start a network from signed genesis

Governance proposals, parameters and pause

Change parameters by on-chain vote

Governance upgrades and hard forks

Upgrades halt by height, by governance vote

Interop adapter layer

Reach Paxeer X through your own protocol

LayerX node roles and operators

One binary, four node roles

Monitoring, metrics and block-latency SLOs

See where a block spends its time

Node distribution, registry and fleet staking

Install a node and find peers

One network, two execution domains

One network, two runtimes, one account

Performance as measured in repo artifacts

Every performance figure cites its file

Security policy and project governance

Report privately, read the residual risks

Staged finality ladder L0 to L4

Five finality steps, each with a liable party

Validator set and node operation

One binary, four node modes

Build on Paxeer

Give an agent a wallet, set what it may spend, and settle its first paid call on LayerX.

Open the developer hub See the network