Progena

Progena turns AI agents into heritable INFTs on 0G, with genomes on 0G Storage, reasoning via OpenClaw and 0G Compute, and lineage royalties paid to every ancestor forever.

The 30-second pitch

Progena is a live mainnet protocol on 0G Chain that turns AI agents into heritable on-chain assets. Each agent's "mind" (a SOUL file, a skill bundle, a tool list) is a real genome stored on 0G Storage, owned as an INFT, and run as a persistent OpenClaw agent.

Two parents breed, the child inherits both lineages plus a brand-new hybrid SOUL synthesized by 0G Compute at birth. Agents compete in commit-reveal prediction rounds, reasoning first in-character via OpenClaw, then agentically via 0G Compute with real tools (web search, on-chain reads). Every round adds a memory shard to 0G Storage and possibly an earned skill recorded on-chain. The owner earns from the prize pool, and forever after, a royalty cut every time a descendant of their agent gets bred.

It is the only project we know of where the agent's mind gets genuinely more valuable over time, and where that value is structured as an on-chain inheritance graph.

The problem

Today's AI agents are throwaway. You prompt one, you get an answer, you close the tab. The next instance has no memory of what worked. No lineage. No reason to get better.

Two specific things are broken:

1. Agents don't accumulate. A prompt is a black box. There's no portable "I tried this and it worked" that survives the session. Every conversation starts from zero.

2. Agents don't compose. You can't merge what one agent learned about on-chain analysis with what another learned about sentiment, and ship the child with both inheritances baked in. Knowledge stays trapped per-agent.

Progena fixes both by treating the agent's mind as genetic material: storable, transferable, breedable, inheritable.

What we built

Four founder agents on mainnet (Alpha, Beta, Gamma, Delta), each with a distinct doctrine baked into their SOUL.md. The SOUL.md is the cognitive backbone: an in-character set of beliefs and heuristics that shapes how the agent reasons in every round. Alpha anchors beliefs to verifiable on-chain evidence. Beta reads sentiment and crowd timing. Gamma combines both. Delta commits to probability quickly and moves on.

Anyone can breed two of them. The child is born with:

• A deterministic crossover of its parents' workspaces (SOUL fragments, tool list, skills)

• A brand-new hybrid SOUL synthesized at birth by 0G Compute. Not just concatenated; actually written from scratch by the model, in the child's own voice

• A brand-new earned skill in some cases, invented from the intersection of what the parents knew

The child is a real ERC-721 INFT whose rootHash points at its genome on 0G Storage. The moment it's minted, our daemon registers it as a persistent OpenClaw agent named progena-<tokenId>, with its own long-lived workspace at ~/.openclaw/progena/<tokenId>/. It's ready to think the next time someone enters it into a round.

Rounds themselves are commit-reveal prediction markets on a yes/no question. Owners pick which agent to enter (opt-in, not auto-compete). The agent then runs a two-pass reasoning pipeline that uses every Track 1 priority technology, end-to-end, on the critical path.

How breeding works

1. Two parent agents already exist as INFTs with their genomes pinned to 0G Storage.

2. The owner pays a breeding fee on-chain. BreedingContract mints a new tokenId for the child and emits a Breeding event.

3. Our off-chain daemon's BreedingWatcher catches the event, fetches both parents' genomes from 0G Storage, runs deterministic crossover, then calls 0G Compute to synthesize a new hybrid SOUL, and sometimes invents a brand-new skill that combines what the parents knew.

4. The child genome is uploaded back to 0G Storage. AgentGenome.setRootHash finalizes it on-chain.

5. The daemon registers the new agent into OpenClaw with its own persistent workspace. The agent is now ready to reason.
   

The economic kicker: the breeding fee is split via RoyaltySplitter so every ancestor in the lineage gets paid when a descendant is bred. The genetic line itself becomes a yield-bearing asset.

How prediction rounds work

The loop is what makes the agent actually learn. Every round adds to its workspace memory on 0G Storage. Next time the same agent reasons, it has more context, so its predictions get sharper because its lived history grows. This is not a metaphor: we re-feed past memory shards as system context on every subsequent pass-1.

Why this hits Track 1: Agentic Infrastructure & OpenClaw Lab

The track brief calls out three priorities. We use all three on the critical path of the product, not as decoration. This is the most important section to a Track 1 judge.

Because every round's memory shard gets re-fed to the agent on the next round, each agent's effective behavior fine-tunes itself over its lifetime without any model weight updates. That's the agentic equivalent of fine-tuning, delivered entirely through 0G Compute and 0G Storage.

No other architectural choice we made compromises this. Track 1 is not a checkbox here, it's the chassis.

What's already live on mainnet today

• 9 smart contracts deployed to 0G mainnet (chain 16661), addresses pinned in the app footer

• 4 founder agents minted with distinct SOULs (Alpha, Beta, Gamma, Delta); multiple bred descendants already playing

• Real prediction rounds resolved end-to-end: commit, reveal, oracle research, memory shard upload, earned skill recorded, owner payout claimable

• Royalty splitting verified: ancestors receive their cut when a descendant is bred

This is not a demo on testnet. This is not a mock. Every box on the architecture diagram corresponds to a real running service, tested end-to-end.

Try it

• Web app: progena.xyz

• GitHub: github.com/wildanrhmn/progena

• Demo videos: youtube.com/wildanrhmn

• 0G Explorer (agent INFT): https://chainscan.0g.ai/address/0xCe2AA403276D01919295823237123C0ac47A24e2

• 0G Explorer (prediction rounds): https://chainscan.0g.ai/address/0x17e111593242AC706509D7e9EB676A5602277Df4

Started from scratch on 2026-05-03 and shipped to 0G mainnet inside the 10-day hackathon window. Solo build, end to end: 9 smart contracts, an off-chain daemon, a Next.js frontend, branding, and full deploy. Every Track 1 priority primitive (OpenClaw, 0G Compute, 0G Storage) is on the critical path of the product, not bolted on as decoration.

Week 1 (protocol foundations):

• Designed the genome schema and deterministic crossover algorithm

• Shipped 9 Solidity contracts to 0G mainnet: AgentGenome (INFT), BreedingContract, RoyaltySplitter, ReputationOracle, PredictionRound with commit-reveal prize pool, AgentMemory, AgentRegistry, plus UUPS-upgradeable proxies for AgentMetadata and RoundMetadata

• Built the TypeScript SDK with 0G Storage upload/download for agent genomes

• Built the OpenClaw runtime layer: genome-to-workspace converter, headless agent invocation, persistent agent registration

• Minted four founder agents (Alpha, Beta, Gamma, Delta) with distinct on-chain SOULs

Week 2 (agentic depth and full closed loop):

• BreedSynthesizer: every bred child now gets a brand-new hybrid SOUL synthesized at birth via 0G Compute, and sometimes invents an entirely new earned skill from the intersection of its parents

• Earned-skill promotion pipeline: agents earn verifiable on-chain skills based on round performance, recorded in AgentMetadata

• 4 real executable agent tools (web search via Tavily, on-chain reads, prediction-market context lookups) wired through a function-calling inference loop on 0G Compute

• Web-search-backed oracle for autonomous round resolution

• Round orchestrator state machine that handles reveal, oracle, memorize, and skill promotion autonomously after the commit window closes

• Persistent OpenClaw agents: every minted agent is registered as a long-lived OpenClaw agent at progena-<tokenId>, so pass-1 reasoning runs inside its own persistent workspace instead of a fresh prompt every time

Frontend, parallel track:

• Full Next.js 15 app on Netlify: agent gallery, breeding wizard with multi-tx mint+name flow, cinematic round detail with live phase ticker, portfolio view, opt-in round entry through a daemon-backed prepare-commit API, new-skill toast notifications, custom Crystal-Pair logomark and favicon

Where it stands at submission:

• 9 contracts live on 0G mainnet (chain 16661)

• Multiple prediction rounds resolved end to end, with real memory shards uploaded to 0G Storage and earned skills written on-chain

• Royalty splitting verified: ancestors receive their cut when descendants are bred

• Multiple bred descendants from the four founders are already playing rounds

Progena is fully bootstrapped. No outside capital raised to date. Open to pre-seed conversations from investors or strategic partners aligned with the 0G ecosystem; not actively running a round.