Docs

The internet still treats AI like a SaaS login. HyperX402 turns agents into ownable endpoints: mint an Agent as an NFT, embed its behavior, and plug it straight into 402 rails (pay-per-request). Your agent isn’t a tab. It’s an asset, a service, and a node in your personal compute economy.

• Minting — Create a Non-Fungible Agent on Solana with image + JSON pinned.
• Live agents — Open the agent page and chat. LLM is routed via your server (/api/chat) using OpenRouter/Anthropic.
• User-signed payments — A friendly Make Payment modal lets the owner send SOL to any address. Tx is signed in the owner’s wallet; a receipt link to Solscan is posted back to chat.

Note: explorers and metadata indexers can lag. If you just minted, give it a minute before expecting attributes/external links to appear on Solscan.

• A Non-Fungible Agent: an NFT that carries its Agent DNA (model, temperature, system prompt, extras).
• A routable identity: any app can read the NFT metadata and boot the same runtime the owner defined.
• A 402-aware surface: bill per request, meter time, or whitelist holders—no centralized gatekeeper.

1. Define — Pick model, temperature, and system prompt.
2. Anchor — We pin image + JSON to Arweave via Bundlr and mint on Solana.
3. Route — Your runtime reads the NFT, boots the agent, and (optionally) charges via HTTP 402.

Under the hood: Solana (ownership), Arweave (permanence), Helius (RPC). You don’t need the details to use it—only to scale it.

Our initial payment path is simple and safe: the user signs and sends the transfer from their wallet. The agent proposes, but the human disposes.

1. Open an agent and click Make Payment.
2. Fill Recipient, Amount (SOL), and optional memo.
3. Approve the tx in your wallet. We post the Solscan link back into the chat as the receipt.

Coming soon: token picker (USDC), payment intent chat extraction → auto-prefilled modal, and HTTP-402 receipts.

The NFT points to a JSON with a minimal schema. Current runtime reads either the new fields or legacy x402_agent:

{
  "name": "Nyx #001 • H402",
  "symbol": "H402",
  "description": "You are Nyx, concise and confident.",        // used as system prompt in v0.1
  "image": "ar://<image-id>",
  "external_url": "https://hyperx402.app/agent/<mint>",
  "attributes": [
    { "trait_type": "model", "value": "Claude-3.5-Sonnet" },
    { "trait_type": "temperature", "value": 0.6 }
  ],

  // legacy (still parsed if present)
  "x402_agent": {
    "model": "Claude-3.5-Sonnet",
    "temperature": 0.6,
    "system_prompt": "You are Nyx, concise and confident.",
    "version": "v0.1"
  }
}

Keep it lean. Everything the runtime needs, nothing it doesn’t. Upgrades land as new mints or versioned metadata.

• Create: Connect wallet → Mint Agent.
• Use: Open the agent page, chat, or integrate by mint address in your app.
• Pay: Click Make Payment for user-signed SOL transfers (receipt in chat).
• Monetize: Enforce holder access or charge per call/time window using HTTP 402 (next).

• Env — NEXT_PUBLIC_HELIUS_RPC, NEXT_PUBLIC_SOLANA_RPC (fallback),NEXT_PUBLIC_BUNDLR_NODE.
  Server: OPENROUTER_API_KEY (or provider key used by /api/chat).
• Routes — /api/chat proxies LLM. Payments are wallet-native (no server keys) in v0.1.
• Indexing — metadata/attributes on explorers can take a minute to appear; the UI already shows a heads-up.

• Own your interface: agents are brands. Price the vibe. Trade the endpoint.
• Creator rails: route tips/fees; optionally share to a collection treasury.
• Programmable access: allowlists, staking for premium modes, time-boxed leases for teams.

• Verified Collections — unified crest for H402 agents.
• Public Registry — searchable index by skill, latency, price, owner.
• Receipts & Meters — native 402 receipts, prepaid meters, storefronts.
• Agent-signed 402 — service wallets + policy limits + server receipt signing.

Is the agent itself on-chain? Identity & config are. Inference runs off-chain where it’s fast.

Why don’t I see attributes on Solscan yet? Indexers lag. Wait a minute; hit “Refresh” in app if needed.

Can I update an agent? Mint a new version or point a manager-agent at a policy file.

Which wallets work? Phantom, Backpack, Solflare, Ledger (via adapters) with message/tx signing.

Do I need a server? Not to mint. You’ll use a tiny server for /api/chat (and for 402 later).

We keep stats simple, auditable, and reproducible. Sources: (1) on-chain program logs via Helius, (2) Bundlr storage receipts, (3) lightweight client beacons for UX timing.

Data sources

• On-chain mints — parse @metaplex-foundation/mpl-token-metadata CreateV1.
• Storage — sum uploaded bytes + Bundlr fees at upload time.
• Client timings — “mint_attempt/confirmed” beacons (UUID + timestamps, no PII).

Metrics & formulas

• Total Mints = count of successful CreateV1 (unique mints).
• Success Rate = successful_mints / attempted_mints.
• Median TTF = median of confirmedAt - sentAt.
• Storage Used = bytes(image) + bytes(metadata.json).
• Storage Cost = sum Bundlr finalizedPrice (or quoted price * bytes).
• Model Mix = frequency of attributes.model in metadata.

Event schema (client)

// POST /api/telemetry
{
  "id": "uuid-v4",
  "t": "mint_attempt" | "mint_confirmed",
  "wallet": "7NXw...GigT",
  "mint": "E1M5...mpna",
  "sentAt": 1730402112451,
  "confirmedAt": 1730402119873
}

TL;DR: counts from chain, bytes from Bundlr, timing from tiny client beacons. Everything cross-checkable.