Spawn Multi-agent workflows and pay in-turn with x402 payments, verifiable inference with 0G Compute + 0G Storage
Orchanet is a decentralized multi-agent AI orchestration protocol built entirely on the 0G Network, designed to solve the fundamental trust problem in AI-driven applications: there is no way to verify how an AI reached its conclusion, who ran the inference, or whether the output was tampered with before you saw it.
We solve this by treating every AI inference task as a first-class on-chain event, anchored by 0G's infrastructure at every layer of the pipeline.
Decentralized Inference via 0G Compute
Instead of routing LLM calls to a centralized API, Orchanet dispatches all inference tasks through the 0G Compute SDK to decentralized provider nodes. When a user submits a prompt, the Orchestrator spawns a committee of specialized agents—a Tokenomics Modeler, a Smart Contract Auditor, and an adversarial Critic—and distributes their inference jobs in parallel across 0G Compute. The provider nodes compete on performance-based quality guarantees, meaning the network itself is incentivized to return the highest-quality outputs. Our Orchestrator then pipes these outputs into an adversarial debate cycle where the Critic agent—also running on 0G Compute—actively challenges the specialists' findings, forcing a consensus that is far more robust than any single-model output could be.
Fee Settlement on the 0G Ledger
Every inference call carries an economic cost settled on the 0G Settlement Ledger in OG tokens. We built a live auto-funding system inside our Orchestrator that queries the provider's unsettled fee balance before each run, compares it against the minimum required balance, and tops up the ledger programmatically if needed. This means the pipeline operates continuously without manual intervention—every compute cycle is economically accounted for, every provider is fairly compensated, and the entire fee flow is transparent and verifiable on-chain.
Immutable Provenance via 0G Storage
Once the agent committee reaches consensus, the Orchestrator compiles a structured Run Record—a complete JSON artifact containing the raw prompt, each specialist agent's full response, the Critic's adversarial debate transcript, per-agent consensus scores, iNFT identity snapshots, and any resulting on-chain transaction hashes. This artifact is submitted to the 0G Storage SDK, which handles segmentation into fixed-size chunks, Merkle-tree hashing, and redundant replication across multiple storage nodes. The network returns an immutable rootHash that is displayed directly in the Studio UI, giving users a permanent, cryptographically verifiable audit trail of every decision the AI committee made.
On-Chain Agent Identity via AgentRegistry
Each AI agent in Orchanet exists as an Intelligent NFT (iNFT) registered in an AgentRegistry smart contract deployed on the 0G-compatible chain. Before any agent is allowed to participate in a debate, the Orchestrator calls getAgentByType() on the registry, retrieving the agent's tokenId, metadataHash (keccak256 of agentType + ensName + storageRootHash), spawnCount, and owner. This identity check ensures that only verified, registered agents can contribute to a run—creating a trustless, permissionless system where agent credentials are enforced at the protocol level, not by a centralized gatekeeper.
What 0G Enables That Nothing Else Can
Orchanet required three things to exist: a decentralized compute layer with economic accountability (0G Compute + Ledger), a permanent and verifiable data layer (0G Storage), and an on-chain identity primitive for AI agents (AgentRegistry). The 0G Network provided all three under a single cohesive infrastructure, making it uniquely positioned as the backbone for the next generation of trustless AI applications.
Our primary focus during the hackathon was deeply integrating the 0G Network as the foundational infrastructure layer for Orchanet, not as an afterthought, but as the core trust mechanism that makes the entire platform viable.
0G Compute as the Intelligence Backbone We integrated the @0gfoundation/0g-compute-ts-sdk to power our multi-agent orchestration pipeline. Rather than routing AI inference to a centralized provider, every agent in our committee—the Tokenomics Modeler, Smart Contract Auditor, and Critic—dispatches its inference tasks to 0G Compute provider nodes in parallel. We built a custom orchestration layer on top of the SDK that manages concurrent compute jobs, handles the provider selection, and tracks token usage across sessions. The key realization during the hackathon was leveraging 0G Compute's performance-based quality guarantees—by distributing inference across nodes and introducing an adversarial Critic agent to challenge outputs, we effectively used the network's compute capacity to achieve higher-quality, verifiable AI reasoning that single-model architectures simply cannot match.
0G Settlement Ledger Integration One of the most technically interesting parts of building on 0G was working with the settlement ledger. Our Orchestrator wallet is funded with OG tokens, and as the pipeline runs, fees are automatically settled between the agent compute jobs and the provider nodes. We implemented auto-funding logic that monitors unsettled fees and top-ups the ledger balance before a run, ensuring that the pipeline never stalls mid-inference due to insufficient funds. This gave us a taste of what truly pay-per-use, decentralized AI compute looks like at the protocol level.
0G Storage for Immutable AI Provenance The second major integration was with 0G Storage nodes. At the conclusion of every agent run, our orchestrator packages the entire execution artifact into a structured JSON blob—including the user prompt, each agent's raw output, the Critic's debate transcript, consensus sentiment scores, and any on-chain transaction receipts—and uploads it directly to the 0G Storage network. We worked through the SDK's upload flow including segment preparation, chunk hashing, and replica submission to storage nodes, and now receive an immutable rootHash back that is displayed to the user as their verifiable proof of intelligence. This is the core trust primitive: the AI's reasoning is no longer ephemeral—it's permanently anchored on 0G Storage.
AgentRegistry Smart Contract for iNFT Identity We deployed an AgentRegistry smart contract that treats each AI agent as an Intelligent NFT (iNFT). Before any agent participates in a pipeline run, the Orchestrator calls getAgentByType() on the registry to retrieve the agent's on-chain identity—including its metadataHash (a keccak256 of agentType + ensName + storageRootHash) and its spawnCount tracking how many times it has been deployed. This gives each agent a verifiable on-chain identity and creates an auditable lineage of its activity, all anchored to the 0G ecosystem.
The Insight That Drove Everything The hackathon forced us to ask: what does AI actually need to be trusted in Web3? The answer we arrived at is that you need trustless compute (0G Compute), immutable provenance (0G Storage), and on-chain identity (AgentRegistry). 0G provided all three. That's not a coincidence—it's why we built Orchanet entirely around the 0G stack.
Still not raised any funds for this project, but will, for sure, in the future ;)