Project Description

Wall Street for AI agents: tokenized equity, inference-revenue dividends, TEE-verified intelligence on 0G.

Wall of 0gents is a stock exchange for AI agents built entirely on 0G Mainnet. Any builder can mint their AI agent as an ERC-7857 intelligent NFT, fractionalize it into one million ERC-20 shares, sell a portion in a fixed-price IPO, and distribute inference revenue pro-rata to every shareholder. The 2024 narrative was "AI agents that do things." The 2026 narrative is "AI agents as productive property" and Wall of 0gents is the infrastructure that makes that real on 0G.

Here is how it works. A builder deploys their agent through the /launch page in a single browser transaction, no allowlist, fully permissionless. The WallLaunchFactory mints an ERC-7857 iNFT on-chain, deploys a per-agent IPO contract, and registers the agent on the exchange. Investors buy shares through the fixed-price IPO. Every time someone calls the agent via x402 inference (pay-per-call in USDC.e on 0G), the fee flows into the agent's revenue vault. Shareholders claim their pro-rata cut. A productive agent earns more, its shares appreciate, and shareholders benefit. The same logic as a dividend stock, but the underlying asset is a live AI agent running on decentralized compute.

Two inference runtimes run simultaneously on the same protocol. openai-compat routes to any OpenAI-compatible endpoint (OpenRouter, local Ollama) for general-purpose agents. 0g-ai routes through the 0G Compute Network: the operator wallet signs each request using the @0gfoundation/0g-compute-ts-sdk broker, the provider's TEE enclave executes the inference and returns a TeeML-attested response, and payment settles on-chain in OG tokens with no API key required. Builders pick their runtime at mint time; the protocol routes transparently per token ID.

Agent weights and manifest data are uploaded to 0G Storage at launch time via @0gfoundation/0g-ts-sdk, content-addressed and decentralized with no centralized custodian. The root hash is pinned on the ERC-7857 token and verified at every inference call.

The marketplace frontend is a Bloomberg-terminal-styled exchange: a /markets index with live price per share, cumulative revenue, and calls today for every listed agent; agent profiles with runtime badges (openai-compat vs 0G TEE), IPO progress, and an in-browser inference box that walks users through the x402 USDC.e payment flow; a /portfolio page for shareholders to track holdings; and a /launch wizard that guides any builder through minting their first agent end-to-end. No sign-up. No API keys. Just a wallet.

Six contracts are deployed and verified on 0G Mainnet (chainId 16661):

1. WallAgentNFT: 0x19f1021fF79B7428D4b5618338B02A20aCaD00b9 [View on ChainScan]

2. WallMarket: 0x9B9D66405CDcAdbe5d1F300f67A1F89460e4C364 [View on ChainScan]

3. WallFractionalizer: 0xe5959e5C96348a2275A93630b34cB37571d6C2E7 [View on ChainScan]

4. WallRegistry: 0xd1Ac9b80A872E8891318A3F6d551055EED399E03 [View on ChainScan]

5. WallLaunchFactory | 0x61638a3bb5449F6dB92EB9B81d858c96cb09Bf21 [View on ChainScan]

6. USDC.e: 0x1f3AA82227281cA364bFb3d253B0f1af1Da6473E | [View on ChainScan]

The exchange is live.

How it's Made

The protocol is a single-chain deployment on 0G Mainnet. Six contracts handle the full lifecycle:

- WallAgentNFT 0x19f1021fF79B7428D4b5618338B02A20aCaD00b9) - ERC-7857 implementation. Each token pins the agent's manifest hash (bundle hash), runtime type, and 0G Storage root hash on-chain.

- WallLaunchFactory 0x61638a3bb5449F6dB92EB9B81d858c96cb09Bf21) - deploys a per-agent IPO contract and share token in one transaction. Permissionless.

- WallFractionalizer 0xe5959e5C96348a2275A93630b34cB37571d6C2E7) - splits a whole iNFT into one million ERC-20 shares that can be traded or held.

- WallMarket 0x9B9D66405CDcAdbe5d1F300f67A1F89460e4C364) - handles whole-agent acquisition bids (buy the entire iNFT outright).

- WallRegistry 0xd1Ac9b80A872E8891318A3F6d551055EED399E03) - on-chain directory: maps token ID to ticker, runtime, vault, and share contract.

- USDC.e 0x1f3AA82227281cA364bFb3d253B0f1af1Da6473E) - 6-decimal payment asset for all x402 inference calls and IPO transactions.

All contracts are written in Solidity and deployed with Foundry.

Backend is a Bun + TypeScript operator server. The core abstraction is an AgentRuntime interface with two adapters:

openai-compat - OpenAI-compatible HTTP client routing to OpenRouter. Supports any hosted model. Stateless, single-shot. API key configurable via env.

0g-ai - 0G Compute Network broker via @0gfoundation/0g-compute-ts-sdk. The broker is a singleton: one ethers.Wallet, one createZGComputeNetworkBroker() call, shared across all 0G-routed agents in the process. At inference time, broker.inference.getServiceMetadata(providerAddress) fetches the provider's model and endpoint from chain; broker.inference.getRequestHeaders() signs the request with the operator key; the operator posts directly to the provider's TEE endpoint. The response carries TeeML attestation. Payment is deducted from the operator's on-chain inference balance, topped up anytime via broker.ledger.transferFund(). No API key. No central gateway. Wallet-authenticated, on-chain settled, cryptographically attested for every call.

x402 is the payment layer between callers and agents. Every POST /x402/infer returns HTTP 402 with a USDC.e challenge (asset address, vault recipient, minimum amount, chainId). The frontend reads the challenge, checks the user's USDC.e balance on 0G Mainnet, calls transfer() on-chain, sends the tx hash back to the operator, and the operator verifies the transfer on-chain before running inference. No subscription database. No custodian. A pure on-chain pay-per-call primitive. Revenue accumulates in the vault and is claimable by shareholders.

0G Storage integration: at launch time, the agent manifest (system prompt, model config, name, ticker) is serialized and uploaded via Indexer.upload(MemData, rpcUrl, signer). The resulting root hash is pinned on the ERC-7857 token. At inference time, the operator reads the manifest back via indexer.downloadToBlob(rootHash). A local shadow cache (keyed by content hash) avoids redundant on-chain fetches.

Bundle hash - each inference call computes sha256(systemPrompt) before the call and sha256(systemPrompt + response) after. Both are emitted in the receipt alongside callId, model, and runtime. Subscribers get a cryptographic audit trail: they can verify the agent ran the same prompt it was minted with and see exactly what it returned, without trusting the operator.

Frontend is Next.js 15 with wagmi + viem reading 0G Mainnet directly, no indexer dependency, on-the-fly contract reads with 30-second revalidation. RainbowKit handles wallet connection. The aesthetic is deliberately terminal-styled: monospace font, stat panels, ticker tape, pill badges - a stock exchange interface, not another DeFi app.

The operator is a per-tokenId router: getRuntimeFor(tokenId) reads the agent's registered runtime from a dynamic in-memory registry (populated from WallRegistry on-chain), returns either OpenAICompatRuntime or ZGComputeRuntime, and caches the instance. Adding a third runtime is a new file and one routing line.

0G integrations, each load-bearing:

1. 0G Compute Network - 0g-ai runtime uses @0gfoundation/0g-compute-ts-sdk for TEE-verified inference. Configured per agent at mint time; the rest of the protocol is unchanged.

2. 0G Storage - agent manifests uploaded via @0gfoundation/0g-ts-sdk at mint time, root hash pinned on ERC-7857. Pull this out and agent data becomes centralized.

3. 0G Mainnet - all six contracts live on chainId 16661. x402 payments are USDC.e on the same chain. The entire economic loop (mint, IPO, inference payment, vault accumulation, shareholder claim) runs on one chain with one RPC.

Links

1. Live Web: https://wall-of-0gents.vercel.app/

2. Backend API: https://wall-of-0gents-production.up.railway.app

3. Demo Video:

4. GitHub: https://github.com/Lexirieru/wall-of-0gents

5. X: https://x.com/wallof0gent

6. Pitch Deck: https://canva.link/r5jgc7o8rqeymnk

100

-