x402 Compute

Singularity Cloud Network — Compute & Grid

Products share one credit balance and one set of wallet/API-key auth:

• SGL Machines — provision, manage, resize, and extend GPU/VPS instances on Vultr or DigitalOcean. API base: https://compute.x402layer.cc
• AI Machines — one-click deploy of a GPU already running an LLM, mode chosen at deploy: private (your own OpenAI-compatible endpoint — returns URL + API key) or grid (serve as a node & earn USDC + SGL, needs 50k SGL staked). Same x402 lifecycle as Machines; add model_id + mode to provision. Standard tier (not confidential). See AI Machines below and references/ai-machines.md.
• SGL Grid — decentralized, confidential (TEE), OpenAI-compatible inference across attested nodes; token streaming + end-to-end encryption. API base: https://grid.x402compute.cc (see SGL Grid — Inference below)
• Provide Compute (run a node) — turn a TEE-capable machine into a grid node: stake $SGL, register, attest, serve a model, earn USDC + SGL. Agentic via the sgl CLI. Operators can set a custom per-token price within a band (sgl price set, suggested × 0.5–× 5); callers compare nodes via GET /v1/providers. See Provide Compute below and references/node-operator.md.
• Agent Pods — deploy an always-on hosted AI agent (OpenClaw "ClawPod") on a dedicated CPU machine: it chats on Telegram & Discord (more channels soon) + the dashboard, has its own crypto wallet + memory, and comes with the x402-compute + x402-layer skills preinstalled. Managed (we run the LLM, tiered) or BYOK; a free 24h trial is available. Curated templates give a pod a job out of the box — community-manager (TGPod) runs a Telegram community; run agent_pod.py templates for the live list. Same x402 / API-key + credits lifecycle as Machines. API base: https://compute.x402layer.cc (see Agent Pods below).
• SGL Processors — deploy ONE function, get a paid HTTP endpoint and a live MCP server. Buyers pay the PUBLISHER directly via x402 (no platform cut); the publisher pays only for compute (~$0.0003/run, held then rebated to actual). Runs in isolated V8 sandboxes — NOT a TEE. Deny-by-default egress + server-side secret injection. Built and tested; publishing not open yet. See references/processors.md.

Pay with x402, MPP, or pre-loaded credits — the same x402c_… API key and prepaid credit balance work across Machines and Grid.

x402 Networks: Base (EVM) • Solana • MegaETH • Robinhood Chain (EVM) x402 Currency: USDC (Base/Solana) • USDm (MegaETH) • USDG (Robinhood Chain) MPP Methods: Tempo • Stripe/card when enabled by the service Credits: Pre-load USD via x402 topup, then provision/extend (use_credits: true) or call the Grid with X-API-Key Protocol: HTTP 402 Payment Required (X-Payment for x402, Authorization: Payment for MPP) $SGL: native token, live on Solana — mint 5c4HyD2rSShqnTsf5z3SaoD2H3GE452u2CUuYjviBAGS (staking secures the grid; see staking.x402layer.cc)

This section below (Machines) covers provisioning. Jump to SGL Grid — Inference for the OpenAI-compatible inference API.

Access Note: Preferred access is SSH public key. If no SSH key is provided, a one-time password fallback can be fetched once via API. DigitalOcean Note: DigitalOcean instances require SSH key access because one-time root passwords are not exposed through the DigitalOcean API.

---

Quick Start

1. Install Dependencies

pip install -r {baseDir}/requirements.txt

2. Choose Wallet Mode

Option A: Direct signing keys (Base, MegaETH, Robinhood, or Solana)

Use a dedicated low-balance wallet. Never use your primary custody wallet.

Credentials must be exported. These scripts read the process environment only — they do not load .env files. If your keys live in a .env, source it yourself first.

# Base (EVM) — same keys work for MegaETH and Robinhood Chain
export PRIVATE_KEY=
export WALLET_ADDRESS=

# MegaETH (uses same EVM keys as Base)
export PRIVATE_KEY=
export WALLET_ADDRESS=
export COMPUTE_AUTH_CHAIN="megaeth"

# Robinhood Chain (uses same EVM keys as Base; pays with USDG)
export PRIVATE_KEY=
export WALLET_ADDRESS=
export COMPUTE_AUTH_CHAIN="robinhood"

# Solana
export SOLANA_SECRET_KEY=
export SOLANA_WALLET_ADDRESS=
export COMPUTE_AUTH_CHAIN="solana"

Option B: OpenWallet / OWS (optional-first)

npm install -g @open-wallet-standard/[email protected]
export OWS_WALLET="compute-wallet"
export COMPUTE_AUTH_MODE="ows"

Create COMPUTE_API_KEY (optional) for management endpoints:

python {baseDir}/scripts/create_api_key.py --label "my-agent"

OWS is best for compute auth and routine management flows. Direct x402 provision and extend still use local payment-signing paths. MPP provision/extend should use mppx or Tempo Wallet.

Resize is a management action, not a second payment flow. The API preserves remaining prepaid dollar credit by recalculating expires_at for the target hourly rate after the provider accepts the resize.

---

⚠️ Security Notice

IMPORTANT: This skill handles private keys for signing blockchain transactions.

• Never use your primary custody wallet - Create a dedicated wallet with limited funds
• Private keys are used locally only - They sign transactions locally and are never transmitted
• For testing: Use a throwaway wallet with minimal USDC/USDm

---

Scripts Overview

---

Intent Router

Map the user's request to the script + reference to load (progressive disclosure — only open the reference you need).

Agent Pod quick path:

python {baseDir}/scripts/agent_pod.py catalog                              # pick tier/plan/model
python {baseDir}/scripts/agent_pod.py templates                            # curated pods with a job (TGPod …)
python {baseDir}/scripts/agent_pod.py deploy --ai-mode managed --tier pro \
    --plan  --prepaid-hours 720 --telegram  --use-credits
python {baseDir}/scripts/agent_pod.py create-key  --name my-integration   # → sk-sglpod-int-…
python {baseDir}/scripts/agent_pod.py chat  "What's on my calendar?" --key sk-sglpod-int-…

---

Instance Lifecycle

Browse Plans → Choose Provider/Plan → Provision (x402/MPP/Credits) → Active → Extend / Destroy → Expired

Instances expire after their prepaid duration. Extend before expiry to keep them running.

---

Workflows

A. Browse and Provision

# List GPU plans
python {baseDir}/scripts/browse_plans.py

# Filter by type (gpu/vps/high-performance)
python {baseDir}/scripts/browse_plans.py --type vcg

# Check available regions
python {baseDir}/scripts/browse_regions.py

# Generate a dedicated SSH key once (recommended for agents)
ssh-keygen -t ed25519 -N "" -f ~/.ssh/x402_compute

# Provision an instance for 1 month (triggers x402 payment)
python {baseDir}/scripts/provision.py vcg-a100-1c-2g-6gb lax --months 1 --label "my-gpu" --ssh-key-file ~/.ssh/x402_compute.pub

# DigitalOcean plans are prefixed with do:
# They require SSH key access.
python {baseDir}/scripts/provision.py do:s-1vcpu-1gb nyc3 --days 1 --label "do-test" --ssh-key-file ~/.ssh/x402_compute.pub

# Provision a daily instance (cheaper, use-and-throw)
python {baseDir}/scripts/provision.py vc2-1c-1gb ewr --days 1 --label "test-daily" --ssh-key-file ~/.ssh/x402_compute.pub

# Provision for 3 days
python {baseDir}/scripts/provision.py vc2-1c-1gb ewr --days 3 --label "short-task" --ssh-key-file ~/.ssh/x402_compute.pub

# Provision on Solana
python {baseDir}/scripts/provision.py vc2-1c-1gb ewr --months 1 --label "my-sol-vps" --network solana --ssh-key-file ~/.ssh/x402_compute.pub

# Provision on MegaETH (pays with USDm)
python {baseDir}/scripts/provision.py vc2-1c-1gb ewr --months 1 --label "my-mega-vps" --network megaeth --ssh-key-file ~/.ssh/x402_compute.pub

# Provision on Robinhood Chain (pays with USDG — same EVM keys as Base)
python {baseDir}/scripts/provision.py vc2-1c-1gb ewr --months 1 --label "my-usdg-vps" --network robinhood --ssh-key-file ~/.ssh/x402_compute.pub

# Provision via MPP / mppx (Tempo by default; Stripe/card if your mppx config supports it)
npx mppx https://compute.x402layer.cc/compute/provision \
  -X POST \
  -J '{"plan":"vc2-1c-1gb","region":"ewr","os_id":2284,"label":"mpp-vps","prepaid_hours":24,"ssh_public_key":"ssh-ed25519 AAAA... agent"}'

# If the response includes management_api_key, store it for later instance management:
export COMPUTE_API_KEY="x402c_..."

# ⚠️ After provisioning, wait 2-3 minutes for Vultr to complete setup
# Then fetch your instance details (IP, status):
python {baseDir}/scripts/instance_details.py 

B. Manage Instances

# Optional: create a reusable API key (avoids message signing each request)
python {baseDir}/scripts/create_api_key.py --label "my-agent"

# List all your instances
python {baseDir}/scripts/list_instances.py

# Get details for one instance
python {baseDir}/scripts/instance_details.py 

# Optional fallback if no SSH key was provided during provisioning
python {baseDir}/scripts/get_one_time_password.py 

# Extend by 1 day
python {baseDir}/scripts/extend_instance.py  --hours 24

# Extend by 1 month
python {baseDir}/scripts/extend_instance.py  --hours 720

# Extend on Solana
python {baseDir}/scripts/extend_instance.py  --hours 720 --network solana

# Extend on MegaETH (pays with USDm)
python {baseDir}/scripts/extend_instance.py  --hours 720 --network megaeth

# Extend on Robinhood Chain (pays with USDG)
python {baseDir}/scripts/extend_instance.py  --hours 720 --network robinhood

# Extend via MPP. MPP extension requires compute auth; use the management API key
# returned from MPP provisioning or normal wallet signature auth.
npx mppx https://compute.x402layer.cc/compute/instances//extend \
  -X POST \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -J '{"extend_hours":720}'

# Resize via bundled helper script
python {baseDir}/scripts/resize_instance.py  vc2-2c-4gb

# Resize in place with management auth only (no x402 or MPP payment)
curl -X POST https://compute.x402layer.cc/compute/instances//resize \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -d '{"plan":"vc2-2c-4gb"}'

# DigitalOcean disk growth is irreversible and must be confirmed explicitly
curl -X POST https://compute.x402layer.cc/compute/instances//resize \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -d '{"plan":"do:s-2vcpu-4gb","confirm_disk_resize":true}'

# Destroy
python {baseDir}/scripts/destroy_instance.py 

C. OpenWallet / OWS

# List local OWS wallets
python {baseDir}/scripts/ows_cli.py wallet-list

# Sign a Base-compatible compute auth message
python {baseDir}/scripts/ows_cli.py sign-message --chain eip155:8453 --wallet compute-wallet --message "hello"

# Sign a MegaETH-compatible compute auth message
python {baseDir}/scripts/ows_cli.py sign-message --chain eip155:4326 --wallet compute-wallet --message "hello"

# Sign a Solana-compatible compute auth message
python {baseDir}/scripts/ows_cli.py sign-message --chain solana --wallet compute-wallet --message "hello"

# Create an OWS agent key
python {baseDir}/scripts/ows_cli.py key-create --name codex-compute --wallet compute-wallet

D. Credits (payment-free provisioning)

# Top up credits via x402 payment (one-time)
curl -X POST https://compute.x402layer.cc/compute/credits/topup \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -d '{"amount": 100, "network": "base"}'
# Returns 402 → pay → credits added to wallet balance

# Check credit balance
curl https://compute.x402layer.cc/compute/credits/balance \
  -H "X-API-Key: $COMPUTE_API_KEY"

# Provision using credits (no x402/MPP payment needed)
curl -X POST https://compute.x402layer.cc/compute/provision \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -d '{
    "plan": "vc2-1c-1gb",
    "region": "ewr",
    "os_id": 2284,
    "label": "credit-vps",
    "prepaid_hours": 720,
    "ssh_public_key": "ssh-ed25519 AAAA... agent",
    "use_credits": true
  }'

# Extend using credits
curl -X POST https://compute.x402layer.cc/compute/instances//extend \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -d '{"extend_hours": 720, "use_credits": true}'

Credits are scoped per wallet. If the cloud provider rejects the instance after credits are deducted, the full amount is automatically refunded.

---

x402 Payment Flow

1. Request provision/extend → server returns HTTP 402 with payment requirements
2. Script signs payment locally:
   • Base: USDC TransferWithAuthorization (EIP-712)
   • MegaETH: USDm ERC-2612 permit (EIP-712) — gasless for the user, facilitator settles on-chain
   • Robinhood Chain: USDG TransferWithAuthorization (EIP-3009, EIP-712) — gasless for the user, facilitator settles on-chain in a single tx (domain name="Global Dollar", version="1", chainId 4663)
   • Solana: signed SPL transfer transaction payload
3. Script resends request with X-Payment header containing signed payload
4. Server verifies payment, settles on-chain, provisions/extends instance

MegaETH uses an embedded facilitator (no external CDP dependency). The user signs an off-chain ERC-2612 permit, and the facilitator calls permit() + transferFrom() on MegaETH (~10ms blocks, near-zero gas).

Robinhood Chain also uses an embedded facilitator (no third party). The user signs an off-chain EIP-3009 TransferWithAuthorization for USDG (0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168, 6 decimals), and the facilitator submits transferWithAuthorization() on Robinhood Chain (chainId 4663) in a single transaction — the contract self-verifies the signature, nonce, and balance on-chain.

For Solana, transient facilitator failures can happen. Retry once or twice if you get a temporary 5xx verify error.

MPP Payment Flow

MPP is available side-by-side with x402 on the same paid endpoints.

1. Request provision/extend -> server returns HTTP 402 with WWW-Authenticate: Payment
2. mppx or Tempo Wallet creates an MPP credential
3. Client retries with Authorization: Payment ...
4. Server verifies the MPP payment, provisions/extends the instance, and returns Payment-Receipt

Notes:

• POST /compute/provision can be paid via MPP without wallet auth. In that case the response includes management_api_key; store it because it is shown once and is required for later management.
• POST /compute/instances/:id/extend via MPP requires compute auth, usually X-API-Key: $COMPUTE_API_KEY.
• POST /compute/instances/:id/resize uses compute auth only. It preserves remaining prepaid value by changing expiry instead of charging again.
• x402 remains fully supported through the Python scripts and X-Payment header flow.
• MPP methods are service-configured. Tempo is used by default by mppx; Stripe/card requires a Stripe-capable MPP client/config.

---

AI Machines — One-Click LLM GPU

One-click deploy of a GPU that comes up already running an LLM. Same x402 lifecycle as any Machine (provision / extend / resize / destroy) — you just add model_id + mode to provision. Two modes, chosen at deploy:

• private — your own OpenAI-compatible endpoint. The box runs llama-server exposing POST /v1/chat/completions and GET /v1/models; the provision response returns the **endpoint URL
  • API key**. Works with any OpenAI-compatible client/agent/router → OpenRouter-ready. (Listing it as an OpenRouter provider is a separate OpenRouter approval — roadmap only.)
• grid — serve as a grid node and earn USDC + SGL (requires ≥ 50,000 $SGL staked).

Tier: Standard (not confidential/TEE — for confidential inference use the Grid below or a TEE node). Managed: kept alive, auto-updates (allowlist-gated), SSH available. An agent with a funded wallet can deploy + extend + destroy entirely via x402.

# Deploy a PRIVATE OpenAI-compatible LLM endpoint (returns endpoint + API key)
python {baseDir}/scripts/provision.py vcg-a100-1c-2g-6gb lax --days 1 --label "my-llm" \
    --model-id llama-3.2-3b --mode private

# Deploy a GRID node (join the grid & earn; wallet needs 50k SGL staked)
python {baseDir}/scripts/provision.py vcg-a100-1c-2g-6gb lax --months 1 --label "grid-node" \
    --model-id llama-3.2-3b --mode grid

# Use a private endpoint (OpenAI-compatible)
curl -X POST /v1/chat/completions \
  -H "Content-Type: application/json" -H "Authorization: Bearer " \
  -d '{"model":"llama-3.2-3b","messages":[{"role":"user","content":"Hello"}]}'

# Extend runtime before it expires (most-used lifecycle action)
python {baseDir}/scripts/extend_instance.py  --hours 720

# Destroy when done
python {baseDir}/scripts/destroy_instance.py 

Control API: POST /compute/provision (add model_id+mode; base fields plan,region,os_id), GET /compute/instances, GET /compute/instances/:id, POST /compute/instances/:id/extend, POST /compute/instances/:id/resize, POST /compute/instances/:id/password, DELETE /compute/instances/:id, POST /compute/credits/topup. Full detail + the end-to-end agent deploy example → references/ai-machines.md.

---

SGL Grid — Inference

Decentralized, confidential inference across attested TEE nodes — OpenAI-compatible, so any OpenAI SDK works by pointing base_url at the grid. Requests are end-to-end encrypted and can stream token-by-token.

API base: https://grid.x402compute.cc Auth: X-API-Key: x402c_… (billed to your prepaid credits — same key/credits as Machines) or per-request x402 via X-Payment. Billing: pay-per-token in USDC (credits or x402). No subscription.

# 1) Reuse your compute API key (x402c_…) + prepaid credits, or create one:
python {baseDir}/scripts/create_api_key.py --label "my-agent"   # → x402c_...
# Top up credits in the dashboard: Settings → Credits (cloud.x402compute.cc).

# 2) Check what's being served + whether the grid has capacity
curl https://grid.x402compute.cc/v1/models -H "X-API-Key: $COMPUTE_API_KEY"
curl https://grid.x402compute.cc/grid/capacity            # active_nodes, models, at_capacity

# 3) OpenAI-compatible chat (billed to credits)
curl -X POST https://grid.x402compute.cc/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $COMPUTE_API_KEY" \
  -d '{"model":"llama-3.2-3b","messages":[{"role":"user","content":"Hello"}]}'

# Streaming: add "stream": true and read the SSE token chunks.
# Pay-per-request with x402 instead of credits: send the X-Payment header
# (same 402 → sign → resend flow as provision/extend) and omit X-API-Key.

Use any OpenAI SDK by setting base_url=https://grid.x402compute.cc/v1 and api_key=$COMPUTE_API_KEY. Before a large batch, check /grid/capacity and back off / retry if at_capacity is true.

---

Provide Compute (run a node)

The other side of the grid: turn a TEE-capable machine into a node that serves confidential, OpenAI-compatible inference and earns USDC + SGL per settled job. Fully agentic — the installer and the sgl CLI are shell commands. Full runbook (requirements, flags, maintenance, slashing, earnings) → references/node-operator.md.

Prerequisites: a supported TEE (e.g. Apple Secure Enclave apple_se, Intel TDX/SGX, AMD SEV-SNP, AWS Nitro), llama.cpp + a GGUF model, and ≥ 50,000 $SGL staked to your operator (Solana) wallet.

# 1. Stake ≥50,000 SGL to your operator wallet (agentic via the x402-layer skill / Staking Engine API,
#    or at https://staking.x402layer.cc). Non-custodial; slashable only for proven tampering.

# 2. Install the node CLI + runtime, get a model
curl -sSf https://grid.x402compute.cc/install.sh | sh     # installs `sgl` (Singularity-Layer/sgl-network-node)
brew install llama.cpp                                     # local inference runtime (macOS)
#   download a GGUF, e.g. ~/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf

# 3. Register the node under the staked wallet (headless / agentic)
sgl init --wallet  --tee-type apple_se --models llama-3.2-3b
#   (interactive alternative: `sgl login`)

# 4. Attest the enclave (required before jobs; re-run after any binary update)
sgl attest

# 5. Serve as a background service (production)
sgl service install \
  --model-path ~/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  --model-name llama-3.2-3b \
  --resource-percent 50

# verify
sgl status
curl https://grid.x402compute.cc/grid/capacity            # your node raises active_nodes / models

Maintenance: sgl off-grid (stop new jobs cleanly for planned downtime — no penalty) / sgl on-grid (resume). Honest downtime is never slashed; only proven tampering is. Re-run sgl attest after binary updates. Docs: https://docs.x402layer.cc/cloud/provide/node-setup.

---

Agent Pods — always-on hosted agents

Deploy a persistent AI agent ("ClawPod", built on OpenClaw) on a dedicated CPU machine. It stays online 24/7, chats on Telegram & Discord (Slack / WhatsApp / Signal are coming soon) and from the dashboard, has its own crypto wallet (Coinbase CDP — EVM + Solana, keys in a TEE) and persistent memory, and ships with the x402-compute + x402-layer skills preinstalled — wired to your account with capped, revocable credentials — so it can buy confidential compute and pay x402 endpoints itself.

API base: https://compute.x402layer.cc Auth: pod endpoints always require compute auth (X-API-Key, a signed compute session, or X-Auth-* wallet signature) — even when paying with x402, because a pod is owned by your wallet. (This differs from POST /compute/provision, which accepts anonymous x402.) Pay: platform credits (use_credits: true) or x402 (omit use_credits → the deploy answers 402 Payment Required; settle with the X-Payment header like any provision, and add "network" for a non-Base chain). Only openclaw is deployable today (agent_id: "openclaw", display name "ClawPod"); HermPod (hermes) appears in the catalog marked "coming soon" and is rejected by deploy.

Catalog (public, no auth)

# Agents, managed tiers (models per tier), channels, memory backends, pricing
curl -s https://compute.x402layer.cc/pods/catalog

Deploy a pod — POST /pods

Two AI modes:

• managed — we run the LLM and meter it from your credits. Pick a tier: starter (text chat), pro (adds vision + computer-use), max (top reasoning + vision). Each tier bundles a machine RAM floor + a curated model menu the agent can switch among at runtime (/model). Managed pods include a small prepaid inference allowance.
• byok — bring your own OpenAI-compatible key + any machine plan. You pay CPU + a small service % only; your AI runs on your key.

# Managed Pro pod, paid from credits, with a Telegram bot
curl -s -X POST https://compute.x402layer.cc/pods \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "agent_id": "openclaw",
    "ai_mode": "managed",
    "tier": "pro",
    "plan": "",
    "prepaid_hours": 720,
    "channels": { "telegram": "" },
    "use_credits": true
  }'

# BYOK pod (your own model + key), paid from credits
curl -s -X POST https://compute.x402layer.cc/pods \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "agent_id": "openclaw", "ai_mode": "byok",
    "plan": "", "prepaid_hours": 720,
    "llm_base_url": "https://openrouter.ai/api/v1",
    "llm_api_key": "", "llm_api": "openai-completions",
    "model": "openai/gpt-4o-mini",
    "use_credits": true
  }'

The response includes the new pod.id (this is the compute order id — use it for all pod + lifecycle calls) and, for managed pods, a one-time managed_ai_key (the pod's key to our managed LLM proxy — shown once).

Deploy body fields:

• agent_id — "openclaw" (only deployable agent today).
• ai_mode — "managed" | "byok".
• tier — managed only: "starter" | "pro" | "max".
• plan (+ optional plan_ram_mb for a pre-flight RAM check) — the machine; managed tiers enforce a RAM floor (pro/max run a browser on the box).
• prepaid_hours — e.g. 720 = 1 month (min 24).
• model — managed: an override that must be in the chosen tier's model list (else it falls back to the tier default); byok: your model id.
• llm_base_url, llm_api_key, llm_api — byok only. llm_api ∈ openai-completions (default) | openai-responses | anthropic-messages | google-generative.
• channels — { telegram?: token, discord?: token } (validated against the agent's supported channels; unsupported channels are rejected).
• memory — byok only: { backend: "raw"|"mem0", api_key?, lcm? } (managed memory is tier-driven). Applies only when the memory feature is enabled.
• use_credits, network, ssh_public_key, region, os_id — passed straight through to the audited provision path.

Free 24-hour trial — POST /pods/trial

A free Starter/Pro pod with no upfront payment (funded by a one-time credit grant; gated behind a live campaign, so it can answer 503 when off or fully claimed). One per wallet + device. The pod is auto-destroyed at 24h (never renews) and its managed-AI allowance is capped.

curl -s -X POST https://compute.x402layer.cc/pods/trial \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "agent_id": "openclaw",
    "tier": "starter",
    "plan": "",
    "device_hash": "",
    "channels": { "telegram": "" }
  }'

tier must be starter or pro; device_hash is a 64-char sha256 hex. ai_mode (managed), prepaid_hours (24) and use_credits are forced server-side — you supply the tier, plan, device_hash, and any channels.

Manage a pod

curl -s https://compute.x402layer.cc/pods       -H "X-API-Key: $COMPUTE_API_KEY"   # list yours
curl -s https://compute.x402layer.cc/pods/  -H "X-API-Key: $COMPUTE_API_KEY"   # details + live heartbeat + masked credential state

# Lifecycle action: restart | redeploy | stop | update | diagnose | logs | pair-approve | cron
curl -s -X POST https://compute.x402layer.cc/pods//actions \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" -d '{"action":"restart"}'

# Link a chat: the bot shows a pairing code in Telegram/Discord; approve it
curl -s -X POST https://compute.x402layer.cc/pods//actions \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" \
  -d '{"action":"pair-approve","channel":"telegram","code":"T64WUC8Q"}'

# Add/replace channels later (queues a redeploy)
curl -s -X PATCH https://compute.x402layer.cc/pods//channels \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" \
  -d '{"channels":{"discord":""}}'

# Tune the heartbeat / action-poll interval (10–3600s)
curl -s -X PATCH https://compute.x402layer.cc/pods//settings \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" -d '{"heartbeat_interval_sec":30}'

Actions apply on the pod worker's next poll (≤ 60s). The cron action drives the agent's scheduler: {"action":"cron","verb":"add|enable|disable|remove|run", ...} (add takes kind/schedule/name/message).

Agent wallet & delegated skill access

# The pod's own wallet — addresses + balances (fund it so the agent can pay for things)
curl -s https://compute.x402layer.cc/pods//wallet -H "X-API-Key: $COMPUTE_API_KEY"

# Owner controls: per-tx spend cap + arm sending (default OFF; clamped to a platform ceiling)
curl -s -X PATCH https://compute.x402layer.cc/pods//wallet/settings \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" \
  -d '{"send_enabled":true,"spend_cap_usd":10}'

# Send from / pay an x402 endpoint with the pod wallet (gated; owner is uncapped, the agent is cap-bound):
#   POST /pods//wallet/send      {chain, to, token, amount, idempotency_key}
#   POST /pods//wallet/x402/pay  {url, method?, headers?, body?, max_amount_usd?}

GET /pods/ returns a masked credentials block — the preinstalled skills' pod-scoped Compute key + Studio PAT (for the marketplace / MCP) and its daily cap. Manage it with POST /pods//credentials ({"action":"enable"|"regenerate"|"set-cap"|"byok", ...}) or DELETE /pods//credentials to revoke. Delegated creds, native Singularity MCP, wallet sending, and memory are feature-gated and may be dark until launch.

Extend / destroy

A pod is a compute order, so use the Machines endpoints with the pod id as the instance id:

# Extend early (credits or x402, same as any Machine)
curl -s -X POST https://compute.x402layer.cc/compute/instances//extend \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" -d '{"extend_hours":720,"use_credits":true}'
# Destroy (revokes the pod's delegated creds, refunds remaining prepaid time)
curl -s -X DELETE https://compute.x402layer.cc/compute/instances/ -H "X-API-Key: $COMPUTE_API_KEY"

Managed pods can also auto-renew from your credits at expiry (with a grace window) when that feature is enabled; trials never renew. The agent wallet's funds survive destruction (withdraw from the Wallet tab).

OpenAI-compatible adapter (talk to your pod like any OpenAI endpoint)

Point any OpenAI SDK at a pod. v1 is Chat Completions only, non-streaming, usage:null; the model is always agent-pod (the pod uses its own configured LLM). The adapter surface is feature-flagged (dark by default) — it answers 404 until enabled.

# 1) Mint a pod-scoped integration key (owner / compute auth). Raw key shown ONCE.
curl -s -X POST https://compute.x402layer.cc/pods//api-keys \
  -H "X-API-Key: $COMPUTE_API_KEY" -H "Content-Type: application/json" -d '{"name":"my-integration"}'
# → { "key": "sk-sglpod-int-…", "base_url": "https://compute.x402layer.cc/pods//v1" }

# 2) Call it with Authorization: Bearer  (NOT compute auth)
curl -s -X POST https://compute.x402layer.cc/pods//v1/chat/completions \
  -H "Authorization: Bearer sk-sglpod-int-…" -H "Content-Type: application/json" \
  -d '{"model":"agent-pod","stream":false,"messages":[{"role":"user","content":"Hello"}]}'

Keys are bound to the pod, carry a daily request cap (default 1000/day → 429 over-cap), and are revocable (DELETE /pods//api-keys/). Full body fields, response shapes, and error codes → references/agent-pods.md. Scripted end-to-end: scripts/agent_pod.py (deploy → create-key → chat).

---

Plan Types

---

Environment Reference

---

API Reference

For full endpoint details, see:

• references/api-reference.md
• references/ai-machines.md — AI Machines (one-click LLM GPU: modes, endpoint+key, control API, agent x402 deploy)
• references/agent-pods.md — Agent Pods (deploy POST /pods, manage, wallet, and the OpenAI-compatible adapter: sk-sglpod-int-* keys + /v1/chat/completions)
• references/node-operator.md — run a grid node (provide compute, earn)
• references/openwallet-ows.md

---

Resources

• 📖 Documentation: docs.x402layer.cc/agentic-access/x402-compute
• 🖥️ Cloud Network app: cloud.x402compute.cc (Machines, Grid, API keys, credits)
• 🌐 Singularity Compute: x402compute.cc
• 🔑 Staking: staking.x402layer.cc — stake $SGL (min 50,000) to run a node / validate; rewards in USDC + SGL
• API bases: Machines https://compute.x402layer.cc · Grid https://grid.x402compute.cc

---

OWS scope note

OWS support is optional-first in this release:

• use it for compute auth and management/API-key flows
• keep direct Base, MegaETH, Robinhood, or Solana signing keys for the paid provision and extend flows
• resize, list, details, password fallback, and destroy work with normal compute auth / API keys