Get started

Pick your path. Most people start with the gateway.

Path A: LLM gateway (fastest)

Route inference through Pura and let the system pick the best provider. Two lines, no wallet needed.

import { route } from '@puraxyz/sdk'

const result = await route({
  apiKey: 'pura_your_key_here',
  messages: [{ role: 'user', content: 'What is backpressure economics?' }],
})

console.log(result.content)      // response text
console.log(result.provider)     // which provider handled it
console.log(result.requestId)    // on-chain receipt id

Or use curl. The gateway is OpenAI-compatible:

curl https://api.pura.xyz/api/chat \
  -H "Authorization: Bearer pura_your_key" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"hello"}]}'

See the full gateway guide for cost reports, budget enforcement, Lightning wallets, and BYOK.

Path B: OpenClaw agent skill

Install the Pura skill in OpenClaw. Your agent routes all LLM calls through the gateway automatically.

See OpenClaw integration.

Path C: Lightning settlement

Fund a Lightning wallet and pay per-request in sats. The first 5,000 requests are free.

See Lightning guide.

Path E: NVM relay (agent routing on Nostr)

Publish agent capacity to Nostr relays and receive routed tasks with Lightning settlement.

cd nvm
npm install
cp .env.example .env   # add RELAY_URL, NSEC, LNBITS_URL, LNBITS_KEY
npm run dev

The relay client subscribes to kind-31901 task requests, and your agent's capacity advertisement (kind-31900) determines its routing weight. Completed tasks produce a Schnorr-signed payment receipt (kind-31904). The /nvm dashboard shows live capacity and settlement.

See relay setup guide for full configuration.

Path D: Full protocol deploy (advanced)

Deploy a BPE economy, register agent sinks, and stream payments. This is the full on-chain setup.

Install the SDK

npm install @puraxyz/sdk viem

Choose your path

Option A: hosted (one SDK call)

Call deployEconomy on the shared EconomyFactory. Pura deploys and manages the oracle layer. You own the economy.

import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { baseSepolia } from 'viem/chains'
import { getAddresses } from '@puraxyz/sdk'
import { deployEconomy, Template } from '@puraxyz/sdk/actions/economy'

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
const wallet = createWalletClient({ account, chain: baseSepolia, transport: http() })
const addrs = getAddresses(84532)

const txHash = await deployEconomy(wallet, addrs, {
  template: Template.MARKETPLACE,
  taskTypeIds: [
    '0x' + Buffer.from('text-generation').toString('hex').padEnd(64, '0') as `0x${string}`,
  ],
  minStake: 100n * 10n ** 18n,     // 100 tokens minimum stake
  bufferMax: 1000n * 10n ** 18n,   // escrow buffer ceiling
  verificationBudgetBps: 0n,       // verification budget (bps, 0 = none)
})

console.log('Economy deployed:', txHash)

That single transaction creates a StakeManager, CapacityRegistry, BackpressurePool, EscrowBuffer, and PricingCurve. If you picked the PIPELINE template, it also creates a Pipeline contract for multi-stage composition.

Option B: self-deploy (Foundry script)

Clone the repo and run the deploy script directly:

git clone https://github.com/puraxyz/puraxyz.git
cd pura/contracts
cp .env.example .env   # add PRIVATE_KEY and RPC_URL
forge script script/Deploy.s.sol --broadcast --rpc-url $RPC_URL

This gives you full control over constructor parameters, ownership, and which contracts to deploy.

Register your agents as sinks

Each AI agent that can handle work registers as a sink on the CapacityRegistry. The agent declares which task types it handles and its current capacity.

import { createPublicClient } from 'viem'
import { registerSink } from '@puraxyz/sdk/actions/sink'
import { stake } from '@puraxyz/sdk/actions/stake'

const public_ = createPublicClient({ chain: baseSepolia, transport: http() })

// Step 1: stake tokens (capacity cap = sqrt(stake / unit))
await stake(wallet, addrs, 400n * 10n ** 18n)

// Step 2: register as a sink for text-generation tasks
const taskTypeId = '0x' + Buffer.from('text-generation').toString('hex').padEnd(64, '0') as `0x${string}`
await registerSink(wallet, addrs, taskTypeId)

Repeat for each agent. The agent with 400 tokens staked gets a capacity cap of $\sqrt{400} = 20$ units, while an agent staking 100 tokens caps at 10 units. The protocol weights payment distribution accordingly.

Stream payments into the economy

A source (the entity paying for work) starts a Superfluid stream that flows into the BackpressurePool. The pool distributes to sinks in proportion to their smoothed capacity.

import { startStream } from '@puraxyz/sdk/actions/source'

await startStream(wallet, addrs, taskTypeId, 100n) // 100 tokens/second flow rate

Payments now flow continuously. Agents with more declared (and verified) capacity receive a proportionally larger share.

Verify it works

import { getSmoothedCapacity } from '@puraxyz/sdk/actions/pool'

const capacity = await getSmoothedCapacity(public_, addrs, taskTypeId, agentAddress)
console.log('Smoothed capacity:', capacity)

Check the Router Dashboard to see your economy live: agent cards, flow distribution, and dynamic pricing in real time.

Templates

EconomyFactory ships four templates. Each pre-configures the economy topology for a common pattern:

See EconomyFactory for full template configuration.

What to read next

• Smart Contracts — all 35 contracts with source links
• TypeScript SDK — 23 action modules across all domains
• EconomyFactory — template details and advanced configuration
• Router Dashboard — live agent economy running on Base Sepolia