Foundry Protocol

Foundry Protocol — the ownership and revenue layer for AI on 0G

Foundry Protocol turns AI models into on-chain assets that the people who actually build them own and earn from. Today, anyone can use a model — but the data providers, compute suppliers, and funders who make it possible capture none of the upside. Foundry fixes that.

Anyone can open a Forge: a pool of data + compute + capital assembled to co-train a real AI model. Every contributor receives proportional on-chain ownership in the form of an Ingot — an ERC-721 cap table for that model. From then on, every single inference automatically routes revenue back to co-owners through an on-chain RevenueSplitter. No middleman, no off-chain trust, no bridges, no manual payouts.

The entire stack runs natively on 0G:

• 0G Storage holds training datasets and model weights, addressed by content root hash.

• 0G Compute TEEs perform training and inference with hardware attestation, so every result is verifiable.

• 0G Chain (Aristotle mainnet, chain 16661) settles ownership minting and per-inference revenue distribution.

Integration is genuinely 3 lines — via the @foundryprotocol/sdk SDK, a drop-in OpenAI-compatible HTTP endpoint, or an MCP server. Any existing AI app (Vercel AI SDK, LangChain, Claude, Cursor, Cline) can switch to a co-owned model with zero rewrite. Every inference returns a TEE-attested, verifiable receipt: requestId, inferenceTxHash, revenueTxHash, latencyMs.

Why this matters for the 0G ecosystem:

1. It makes 0G the home of model ownership. No other chain has a primitive where training a model mints a tradable, revenue-bearing on-chain asset. Foundry makes "own the model, not just rent the API" a 0G-native capability.

2. It drives real, recurring on-chain activity. Every inference is a 0G Chain transaction (inferenceTxHash + revenueTxHash) and a 0G Compute TEE job — so usage compounds into measurable Storage, Compute, and Chain demand instead of one-off deploys.

3. It turns every other 0G project into a stakeholder. Agent, memory, DeFi, and infra teams already produce the data and compute Forges consume. Foundry lets them contribute what they already run and become co-owners — a built-in network effect that keeps builders inside the 0G economy.

4. It composes, it doesn't compete. Foundry is pure ownership + revenue infrastructure. Other 0G projects plug into it as their model backend and inherit verifiable receipts and a passive revenue rail for free.

Live site: https://foundryprotocol.xyz · API: https://api.foundryprotocol.xyz/v1/chat/completions

Foundry Protocol was built entirely from scratch during this hackathon — no prior codebase, no forked starter. We shipped the full vertical, from Solidity contracts to a live product on 0G Aristotle mainnet, through several rounds of iteration.

Iteration 1 — Core ownership primitive. Designed and wrote the contract suite from zero: ForgeFactory, ContributionRegistry, Ingot (ERC-721 model cap table), and IngotRegistry. Proved out the central idea — pooling data + compute + capital and minting proportional on-chain ownership.

Iteration 2 — Revenue and economics. Added FORGEToken and the on-chain RevenueSplitter, closing the loop so that every inference automatically distributes revenue to Ingot co-owners with no manual payout. This is what turned Foundry from "a registry" into "an economy."

Iteration 3 — 0G-native integration. Wired the full lifecycle into 0G: datasets and weights to 0G Storage (content-root addressed), training/inference into 0G Compute TEEs with attestation, settlement on 0G Chain (Aristotle, chain 16661). Every inference now returns a verifiable receipt (inferenceTxHash, revenueTxHash, attestation).

Iteration 4 — Developer surface. Built three integration paths so any team can adopt it in minutes: the @foundryprotocol/sdk TypeScript SDK, an OpenAI-compatible HTTP API, and an MCP server (list_ingots, run_inference, get_ingot, get_lineage, get_attestation), plus drop-in Vercel AI SDK and LangChain adapters.

Iteration 5 — Product, content, and polish. Shipped the live web app — dashboard, forge ledger, Ingot detail views, lineage graph, AI forge wizard, and TEE attestation viewer — full developer docs, and a real live Ingot catalog (5 co-owned models, 4–9 contributors each: Konkani↔English, Konkani news, Tulu↔English, Clause Classifier, MSA-clause).

Final version — deployed and live on 0G Aristotle mainnet (chain 16661):

ContributionRegistry 0x05235Ba0F2a77bcaB87371E4d797D6830ddC2d86

Ingot 0x39B736f424754d05a0da186d89015b74d1DDe1d3

RevenueSplitter 0xC58E0F32BD43e43153D3CA8ee8F25C8198789289

ForgeFactory 0x636109264EBF6cFD18CC38bD43eDf9cCad7ae23D

IngotRegistry 0xF8f3fAE648A8d7ee4Df0A7b10a0F759938aab7e1

The result is a complete, working product — not a prototype: a co-owned model can be forged, deployed, served, and paid out end-to-end on 0G today.

NA