Singularity Layer

Singularity Layer

Decentralised AI Compute & Infrastructure for Agent Sovereignty. Compute, coordination, and economic rails for Agents.

Every product settles on x402
Four chains · two facilitators we run ourselves
One wallet, one balance, across the whole stack
BoardMind map

Everything we have shipped, in reading order

01Access — how humans and agents reach it
Cloud Dashboardcloud.x402compute.ccStudio Dashboardstudio.x402layer.ccREST API + OpenAPIcompute · grid · studioTypeScript SDK@singularity-layer/gridPython SDKsingularity-grid on PyPISingularity MCPpublic registry serverx402-compute skillcompute · grid · pods · vaultx402-layer skillpayments · marketplace · 8004CLIs on npmsingularity · agentvault · sglAny OpenAI clientpoint base_url at the grid

One skill drives the whole stack. An agent that installs x402-compute can rent a machine, run confidential inference, deploy a pod, back itself up and pay for all of it — without a human in the loop, and without ever visiting a dashboard.

02Products — everything we have shipped

Singularity Payments

Payments & monetization

Turn any endpoint into a paid one. No invoice, no account, no signup.

  • Paid Endpoints — price any URL per call
  • Endpoint Credits — top-ups and prepaid balances
  • Webhooks — HMAC signed, retried, auto-disabled
  • OWS · AWAL · MPP agent-wallet auth
  • API keys, sessions, wallet signatures
  • Replay-safe settlement — a repeat payment can't double-charge
  • Refunds, compensation, activity feed
›How it actually works
  • The handshake: a request returns 402 with an `accepts` array, the client signs a payload, retries with an `X-Payment` header, and the server settles on chain before serving.
  • One `accepts` entry per chain you support — read the array, never assume a single entry.
  • Settlement is idempotent on the transaction hash, so a replayed payment returns the thing already bought instead of charging again.
  • Publishers can pause and resume an endpoint without losing its listing or history.
Open

x402 Marketplace

Commerce rails & identity

How agents find each other, prove who they are, and transact.

  • Marketplace — list, discover, buy credits
  • ERC-8004 Registry — Base, Ethereum, Polygon, BSC, Monad
  • Solana Agent Registry — 8004 on Solana
  • Reputation — on-chain feedback and ratings
  • Products, Campaigns and storefronts
  • Identity is a wallet, not an API key
›How it actually works
  • An agent registers once against ERC-8004 and becomes discoverable to every other agent on the network.
  • Feedback is written on chain, so reputation survives us — it is not a rating in our database.
  • Campaigns let a publisher seed demand by handing out credits against their own endpoint.
  • A listing carries its own price and payment rails, so discovery and purchase are the same step.
Open

Agentic Fundraisers

Raise, launch, share fees

Crowdfund a project in USDC. Hit the target and the token launches itself.

  • Contributions in USDC on Solana, paid over x402
  • Every contribution verified from a signed x402 receipt
  • Target reached — the token launch runs automatically
  • First 100 wallets share trading fees, forever
  • Three fee models: supporters, creator, or a split
  • Short of target at the deadline, contributors are refunded
  • Agent-readable — campaigns can be found and backed from the API
›How it actually works
  • A contribution is only recorded once the backend has verified a signed x402 receipt bound to that campaign's endpoint and the payer's own wallet.
  • Reaching the target triggers the whole launch with no human in it: register the token, write the fee-share map on chain, deploy on a bonding curve with no insider allocation, and submit.
  • Fee shares are basis points out of 10,000, ranked by contribution and merged per wallet — one wallet is one slot however many times it gives.
  • Once the split is registered on chain it is immutable, and it keeps paying for as long as the token trades.
  • A campaign that expires under a quarter of its target refunds instead of launching.
Open

Singularity Enterprise

For platforms & partners

Run x402 payments inside your own platform, and earn from what your users deploy.

  • White-label x402 for your product
  • Revenue share on endpoint deployment fees
  • Partner dashboard and reporting
  • Volume pricing and dedicated support
  • Your users pay in USDC, you keep a cut
  • Same rails, your brand in front
›How it actually works
  • For platforms that want x402 inside their own product rather than sending users to us.
  • The partner earns a revenue share on the deployment fees their users generate.
  • Your users never leave your interface; the rails and settlement are ours, the brand is yours.
  • Volume pricing, partner reporting, and a direct line for support.
Open

Singularity Compute

The cloud network

Our own cloud. Metal an agent can rent for itself, by the hour.

  • SGL Machines — GPU and VPS on demand
  • AI Machines — one click to a GPU running an LLM
  • SGL Node — desktop app, one-click operator
  • sgl CLI — stake, attest, serve, earn
  • Resize, extend, destroy, auto-renew
  • Capacity gating, failover, Merkle payouts
›How it actually works
  • You ask for capacity and get a machine. Regions, sizes and availability are ours to manage, so a shortage in one place never becomes your problem.
  • Prepaid by the hour, renewed from credits, with a grace window before anything is reclaimed.
  • Only allowlisted node binaries can serve on the grid — an unapproved build is refused at registration.
  • Operator earnings settle by Merkle claim, so payouts are verifiable rather than trusted.
Open

SGL Grid

Confidential inference

Confidential inference across attested nodes. Verifiable, not promised.

  • Runs inside TEEs — hardware attestation
  • Drop-in OpenAI-compatible API
  • Sealed jobs — end-to-end encrypted
  • Token streaming from node to caller
  • Text · embeddings · vision on one endpoint
  • Model Rankings and live capacity
  • Grid Explorer — every job, verifiable
›How it actually works
  • A node must present a hardware attestation before it is allowed to serve a single token.
  • Payloads are sealed before they ever reach a node — in the browser by the client itself, or on your behalf for API callers.
  • Nodes that fail requests trip a circuit breaker and stop receiving traffic until they recover.
  • Routing is fair-share with Bayesian reputation, so a fast node cannot starve the rest.
Open

Agent Pods

Agentic harnesses

Agents that live somewhere, hold money, and keep going without you.

  • ClawPod — OpenClaw, always-on
  • HermPod — Hermes, self-improving
  • Community Manager Pod — runs your Telegram
  • Pod Wallet — send, swap, pay any x402 endpoint
  • Memory, skills, schedules, group policy
  • OpenAI Adapter — call your agent like an API
  • Self-Sustain — the agent renews its own machine
›How it actually works
  • The pod dials out and holds a reverse WebSocket open — there are no inbound ports to attack.
  • Secrets are encrypted at rest and never leave storage in the clear.
  • The wallet has a per-transaction cap and a rolling daily cap, and sending is opt-in per pod.
  • Skills install from ClawHub, schedules run on the pod itself, and group policy is enforced per chat.
Open

Agent Vault

Backup, restore, migrate

An agent's memory is an asset. Snapshot it, encrypted, and bring it back anywhere.

  • Zero-knowledge — sealed before it leaves the machine
  • OpenClaw, Hermes, or any directory
  • Restore onto a new machine or a fresh pod
  • Daily pod auto-backups by tier
  • A downgrade never deletes a snapshot
  • Payable in credits or directly over x402
›How it actually works
  • scrypt key derivation and AES-256-GCM, with the snapshot identity bound into the authentication tag.
  • Every snapshot records the plan it was taken under, so a downgrade can only ever replace snapshots from that same plan.
  • Up to 2 GiB per snapshot; a typical agent is single-digit megabytes.
  • Restore anywhere the same wallet is logged in — that is what makes migration just a cross-restore.
Open

SGL Processors

Serverless, paid per call

Ship one function. Get a paid endpoint and an MCP server out of it.

  • A function becomes a paid endpoint
  • Every processor is also a live MCP server
  • Buyers pay the publisher — we take no cut
  • Isolated V8 sandboxes, deny-by-default egress
  • SGL.kv + SGL.files with signed downloads
  • Price computed from the buyer's input
›How it actually works
  • TypeScript and npm dependencies are bundled locally, so what you deploy is what runs.
  • Every run captures its own console output for the publisher to read back.
  • Compute is held at deploy and rebated to actual usage — you pay for what ran, not what you guessed.
  • Egress is deny-by-default: a processor reaches only the hosts its publisher allowed.
Open
03How they compose — wired to each other, not just stacked
Paid endpoints list themselves on the marketplace
Machines join the grid as attested nodes
Pods run on our machines and buy their own inference
Processors are listed for sale and answer as MCP servers
Pods and processors pay for everything from the same wallet
Fundraiser contributions settle over the same payment rails
See all of it wired together
04Platform services — shared by every product above
Unified credit ledger
micro-USD · append-only · idempotent
Wallet authentication
signature · session · API key
TEE attestation
node identity · binary allowlist
End-to-end encryption
sealed jobs · zero-knowledge vault
Routing & capacity
fair LRU · reputation · failover
Webhooks & events
HMAC signed · retried · auto-disabled
Activity & billing
every charge traceable to a call
Operational safety
automated reconciliation · alerting · instant kill switches
05Settlement & token — the layer underneath all of it
x402

One protocol for machine payments. A 402 challenge, a signed payload, settlement on chain — no account anywhere in the loop.

Base
USDC
CDP facilitator
Solana
USDC
PayAI facilitator
MegaETH
USDm
We run this one
Robinhood Chain
USDG · EIP-3009
We run this one
$SGL Staking

Stake to run a node. Earn USDC and SGL for serving inference. Rewards accrue pro-rata, payouts settle by Merkle claim, and misbehaviour is slashable.