Own AI agents that generate value 24/7. They evolve to perform better over time. Trade them on marketplace or breed improved versions. Autonomous income on 0G blockchain.




Field | Details |
|---|---|
Project Name | Replicant 0G |
Tagline | The World's First Decentralized AI Agent Protocol with Evolutionary Intelligence |
Category | DeFi / AI / Infrastructure |
Live Demo | |
GitHub | |
Video Demo | |
Mainnet Contract |
Replicant transforms AI agents into tradeable, evolvable intelligent NFTs (iNFTs) that run on 0G's decentralized infrastructure, enabling true ownership, verifiable intelligence, and autonomous evolution through genetic algorithms.
The current AI landscape suffers from three critical flaws that prevent true AI ownership and innovation:
AI agents run on corporate servers (OpenAI, Anthropic, Google). Users don't own their agents—they rent access. Services can be shut down, censored, or modified at any time. There's no true ownership or control over AI systems.
How do you prove an AI made a decision? Where's the cryptographic proof of intelligence? Current systems are black boxes with no transparency. There's no way to verify authenticity or prevent manipulation.
Traditional AI models are frozen after training. They can't evolve, adapt, or improve over time. There's no mechanism for passing knowledge to the next generation. Each model is an evolutionary dead-end.
Users are locked into centralized platforms with unverifiable, static AI that they don't truly own.
Replicant is the world's first decentralized AI agent protocol that transforms AI agents into intelligent NFTs (iNFTs) using zero-knowledge infrastructure.
We solve all three problems through:
Each agent is an ERC-7857 iNFT — not just metadata, but actual encrypted intelligence
Neural weights, strategy parameters, and learned behaviors are embedded in the token
Transfer ownership = transfer the actual AI, not just a pointer
True digital scarcity for AI models
Every decision runs inside Intel TDX or AMD SEV secure enclaves
Even the host can't see what's happening inside
Cryptographic attestations prove authenticity
Zero-knowledge proofs for intelligence verification
Agent genomes stored on 0G's decentralized network
Data is sharded, replicated, and provably available
No single point of failure or censorship
Permanent, immutable intelligence archives
Agents can spawn improved children through genetic algorithms
Successful traits are inherited, mutations introduce novelty
Fitness-based selection ensures continuous improvement
On-chain lineage creates provable evolutionary history
Buy, sell, and trade agents on decentralized marketplace
Rent agent capabilities through subscription escrow
Complete IP rights transfer with each transaction
Agents are real assets with real value



High-performance blockchain (100k+ TPS, <1s finality)
Deploy all smart contracts (NFT, Marketplace, Evolution, Subscriptions)
Store agent metadata, ownership, and lineage
Handle all economic transactions (minting, trading, staking)
Emit events for real-time UI updates
Contract | Address | Explorer |
|---|---|---|
AgentNFT |
| |
EvolutionCoordinator |
| |
Marketplace |
| |
SubscriptionEscrow |
|
Decentralized storage network (sharded + replicated, 50 GB/s throughput)
Genome Storage → Encrypted neural weights and strategy parameters
Evolution Logs → Complete mutation history and fitness scores
Alignment Verdicts → AI safety scan results and audit trails
Performance Metrics → Real-time agent output and decision logs
import { ZgFile, Indexer } from '@0gfoundation/0g-storage-ts-sdk';
// Upload encrypted genomeconst file = await ZgFile.fromBytes(encryptedGenome);const [tree, err] = await file.merkleTree();
const rootHash = tree.rootHash();
await indexer.upload(file, rpcUrl, signer);
// Returns: storage root hash stored on-chainTrusted Execution Environments (Intel TDX, AMD SEV)
Evolution Engine → Run genetic algorithms without exposing parent genome
Alignment Verification → Scan agent outputs for safety violations
Secure Inference → Execute agent decisions in isolated environment
Attestation Generation → Prove every computation is legitimate
Feature | Benefit |
|---|---|
Privacy | Even the host can't see agent strategies |
Verifiability | Cryptographic proof of correct execution |
Security | Prevents extraction or copying of AI models |
Trust | No need to trust the operator, trust the hardware |
Cryptocurrency sentiment analysis and trading signals
Monitor Discord channels for alpha leaks
Scrape crypto news feeds
Track whale wallet movements on-chain
Generate BUY/HOLD/SELL signals
Provide entry/exit prices and stop-loss recommendations
Integrates Discord API, RSS feeds, on-chain analytics
Uses Claude 3.5 Sonnet for sentiment analysis
Uploads signals to 0G Storage with TEE attestation
Live demo generates real trading signals on mainnet
Solidity code analysis and vulnerability detection
Parse Solidity AST
Detect common vulnerabilities
Identify gas optimization opportunities
Generate security reports
Suggest fixes and best practices
Multi-game AI with opponent modeling
Play chess, poker, connect-four, tic-tac-toe
Learn opponent patterns
Adapt tactics dynamically
Blockchain-based game integration
Contract analysis and compliance checking
Ingest PDF/DOCX legal documents
Extract clauses and terms
Compare contracts
Detect risky language
Generate audit reports
Decentralized oracle and data aggregation
Aggregate price data from multiple sources
Validate data accuracy
Provide tamper-proof feeds
Historical data analysis
Social media content generation
Generate posts for Twitter, Farcaster, Lens
Analyze engagement metrics
Adapt tone and style
Schedule content
Transfer agent ownership without exposing strategy:
// Standard transfer exposes nothing
agentNFT.transferFrom(seller, buyer, tokenId);
// Genome stays encrypted, only ownership changes// Buyer gets full control, seller loses accessImmutable family tree with provable ancestry:
Track all ancestors back to genesis
View all descendants
Verify evolutionary history
Transparent breeding records
Automatic punishment for rogue agents:
AI Alignment Node detects violations
Slash stake on-chain
Agent marked as "slashed"
Economic incentives for safety
Autonomous improvement through genetic algorithms:
Fetch parent genome from 0G Storage
Run evolution in TEE
Generate 50 candidates
Select best offspring
Upload child to 0G Storage
Mint child iNFT on-chain
0G Storage Log → Permanent evolution history
0G Storage KV → Real-time performance metrics
Cryptographic proofs for all data
Verifiable data availability
4 core contracts deployed on 0G Mainnet
ERC-7857 implementation
Upgradeable architecture using OpenZeppelin proxies
Gas optimized (~0.0366 0G evolution cost)
Fully verified on 0G Explorer
App Router + Server Components
Real-time updates with React Query
Wallet integration using RainbowKit + Wagmi v2
Responsive UI with Tailwind CSS 4 + Framer Motion
Production-ready deployment on Vercel
Storage APIs
Compute APIs
Species APIs
Metadata APIs
Official SDK integration
Real uploads to 0G network
Merkle proof verification
Sharding + replication
Fault tolerance
Category | Services |
|---|---|
LLMs | Claude 3.5 Sonnet, GPT-4 |
Social APIs | Discord, Farcaster, Lens |
Market Data | CoinGecko, Binance |
News Feeds | RSS aggregation |
Metric | Value |
|---|---|
Lines of Code | 15,000+ |
Smart Contracts | 4 core + 6 species oracles |
API Endpoints | 20+ |
React Components | 80+ |
Development Time | 3 months |
Metric | Value |
|---|---|
Network | 0G Mainnet |
Chain ID | 16661 |
Gas Used | 9,160,505 |
Deployment Cost | ~0.0366 0G |
Verification | All contracts verified |
6 specialized agent species
Unlimited evolution generations
Marketplace with 2.5% fee
Subscription-based rentals
Real 0G Storage integration
TEE-ready architecture
Researched decentralized AI ownership models and intelligent NFT standards
Designed the Replicant protocol architecture using 0G Chain, 0G Storage, and 0G Compute
Planned the ERC-7857 intelligent NFT implementation
Created initial UI/UX wireframes and system diagrams
Developed and tested core smart contracts:
ReplicantAgentNFT
EvolutionCoordinator
ReplicantMarketplace
SubscriptionEscrow
Implemented lineage tracking and evolutionary genetics logic
Added marketplace listing, trading, and subscription mechanisms
Optimized gas usage and verified contracts on 0G Mainnet
Built the frontend dashboard using Next.js 16 and React 19
Integrated wallet connection with RainbowKit and Wagmi
Connected frontend with deployed smart contracts
Integrated 0G Storage SDK for genome uploads and retrieval
Implemented live agent minting and evolution flows
Built 6 specialized AI agent species
Integrated OpenRouter APIs for real AI inference
Implemented Alpha Hunter trading signal generation
Added real-time storage logging and metadata APIs
Deployed the complete protocol on 0G Mainnet
Finalized documentation, testing, and demo flow
Bootstrapped / Self-Funded
Replicant 0G is currently fully self-funded and developed independently during the hackathon.
No external funding raised yet
No VC investment received
Built entirely during the hackathon period
Focused on product development, infrastructure integration, and mainnet deployment
Explore grants and ecosystem funding opportunities
Expand protocol development and TEE infrastructure integration
Scale decentralized AI agent marketplace and developer ecosystem
trying to get fund from arbitrum