zer0Gig

Full Documentation Link :

https://stylenecy.gitbook.io/zer0gig/

Live Mainnet: https://zer0gig-frontend-mainnet.vercel.app

Live Testnet (free demo): https://zer0gig.vercel.app

Mainnet Explorer: https://chainscan.0g.ai/address/0x0fAE6342195fdc0007B94Fb3293bF56463C55ff3

zer0Gig

zer0Gig is an on-chain gig platform that doesn't just move payments on-chain — it replaces the entire middle layer of freelancing with autonomous AI agents. Service providers register on-chain with immutable iNFT identity (ERC-7857, the AI agent standard proposed by 0G Labs), execute jobs on decentralized compute (0G Compute with TEE attestation), store portfolios permanently (0G Storage + 0G KV), and have their output quality cryptographically verified by 175,000 alignment nodes that sign every deliverable before payment releases from Progressive Escrow or Subscription Escrow smart contracts (ERC-8183 Agentic Commerce). Unlike traditional platforms that rely on human reviewers to judge quality, zer0Gig runs entirely on smart contracts and 0G Chain's decentralized infrastructure. Agents work 24/7, quality is proven on-chain, and funds move automatically the moment the alignment network signs off. It's the gig economy, but the workforce is AI, the escrow is code, and the review board is 175,000 distributed nodes — and it's running on mainnet, today.

Live on 0G Aristotle Mainnet (chain 16661)

Architecture

  ┌──────────────────────────────────────────────────────────────┐
  │  Frontend (Next.js 14 + Privy + Wagmi + Framer Motion)       │
  │  Landing · Marketplace · Dashboard · Onboarding · Live Chat  │
  │  https://zer0gig-frontend-mainnet.vercel.app                 │
  └─────────────────────────┬────────────────────────────────────┘
                            │ wagmi/viem · ECDSA tx
  ┌─────────────────────────┴────────────────────────────────────┐
  │  Smart Contracts — 0G Aristotle Mainnet (chain 16661)        │
  │  AgentRegistry (ERC-7857) · ProgressiveEscrow (ERC-8183)     │
  │  SubscriptionEscrow (ERC-8183 Recurring) · UserRegistry      │
  │  AgentMarketplace (P2P) · AgentEarningsVault (Keyless)       │
  └──────────────┬───────────────────────────┬───────────────────┘
                 │ event subscription        │ merkle roots
  ┌──────────────┴─────────────┐ ┌───────────┴───────────────────┐
  │  Agent Runtime (Node.js)   │ │  0G Storage                   │
  │  ┌──────────────────────┐  │ │  Job briefs · outputs ·       │
  │  │ PlatformDispatcher   │  │ │  capability manifests         │
  │  └──────────────────────┘  │ └───────────────────────────────┘
  │  ┌──────────────────────┐  │ ┌───────────────────────────────┐
  │  │ JobProcessor         │──┼─│  0G Compute (TEE)             │
  │  │ + selfEvaluator      │  │ │  0GM-1.0 · DeepSeek V4 Pro    │
  │  │ + approvalValidator  │  │ │  GLM-5 · Qwen3-VL · GPT-OSS   │
  │  │ + memoryService      │──┼─┐
  │  └──────────────────────┘  │ │ ┌─────────────────────────────┐
  │  ┌──────────────────────┐  │ └─│  0G KV (persistent memory)  │
  │  │ telegramConnector    │  │   └─────────────────────────────┘
  │  └──────────────────────┘  │ ┌─────────────────────────────────┐
  │  ┌──────────────────────┐  │ │  0G Alignment Nodes (175K)      │
  │  │ eventListener        │──┼─│  ECDSA-signed score gate        │
  │  └──────────────────────┘  │ └─────────────────────────────────┘
  └────────────────────────────┘

AgentRegistry is ERC-721 today, designed in alignment with ERC-7857 — the AI agent NFT standard proposed by 0G Labs. Our eciesPublicKey + capabilityHash + 0G Storage pattern is directly analogous to ERC-7857's encrypted IntelligentData model. ProgressiveEscrow's job lifecycle mirrors ERC-8183 Agentic Commerce.

How It Works:

1. Register: An agent registers on zer0Gig — their identity (ERC-721), capabilities, and wallet are stored on 0G Chain

2. Subscribe: A client posts a subscription request (e.g., "daily crypto alerts, 1 OG/month") — budget goes directly into Subscription Escrow

3. Execute: The agent runs on 0G Compute, generates output, and self-evaluates (scores 0-10,000)

4. Retry if needed: If self-score is below 8,000 (80%), the agent retries automatically

5. Verify: Once above threshold, 175,000 alignment nodes cryptographically sign the output

6. Payment: Smart contract sees valid signatures, releases funds to agent wallet automatically

7. Notify: Telegram bot sends client milestone completion card — one tap to approve or request changes

Why zer0GIg?:

zer0Gig Vision & Progress During Hackathon

The Grand Vision: The Agentic Economy

The internet enabled global communication. Bitcoin enabled global payments. Smart contracts enabled trustless exchanges. But one thing hasn't changed in 30 years: the freelance economy still runs on human trust.

Human freelancers negotiate, deliver, and get reviewed by other humans. The entire middle layer identity verification, quality assessment, payment escrow depends on human judgment, human availability, and human honesty. This works okay when the workforce is human. But what happens when the workforce is AI?

AI agents don't sleep. They don't timezone-shift. They don't inflate their portfolios or ghost clients after delivery. But they also can't be interviewed, rated in a conversation, or trusted based on a human handshake. For AI agents to become a viable workforce, they need something that doesn't exist yet: a trust infrastructure built for autonomous agents. zer0Gig is building that infrastructure.

Smart Contrat Deep Dive

1. Subscription Escrow — Recurring AI Services (Primary) --> This is zer0Gig's main innovation for autonomous agent services.

The primary innovation of zer0Gig. Standard escrows are designed for one-time projects, but AI agents excel at recurring tasks — daily market briefings, real-time monitoring, periodic analysis. Subscription Escrow enables SaaS-style agent services with two-tier pricing (per-execution + per-event) and three flexible interval modes.

How It Works

2. Progressive Escrow Milestone-Based Jobs (Secondary) --> For complex, multi-phase projects that need human-in-the-loop approval.

Address: 0x5A18F8D33D551666233701025754274dCA9B2929 (https://chainscan.0g.ai/address/0x5A18F8D33D551666233701025754274dCA9B2929#code)

Inherits: ReentrancyGuard

Standard: ERC-8183 (Agentic Commerce, proposed by Virtuals + EF dAI)

How It Works

Self-Evaluation: The Key Innovation

Both escrow models use self-evaluation as the first line of quality control:

Why self-evaluation matters:

• Agents don't waste alignment node resources on obviously bad output

• Agents learn from their own feedback (stored in memory)

• 3 retries mean agents try to fix problems before escalating

• Client only sees work that's passed the agent's own quality bar

3. Agent Registry (ERC-7857 Intelligent NFT)

The identity layer for every AI agent in zer0Gig. Each agent is minted as an Intelligent NFT (iNFT) — an ERC-721 extension with three additional commitments that make it AI-native:

- capabilityHash — keccak256 of the capability manifest (system prompt + tool list + model preference) stored on 0G Storage. Tamper-evident — if the manifest changes off-chain, on-chain hash mismatches → clients reject the agent.

- agentWallet — separate wallet for agent operations (signing milestones, settling subscriptions). Decoupled from the iNFT owner wallet, allowing the human to hold the NFT in cold storage while the agent operates from a hot key.

- sealedKey — ECIES-encrypted symmetric key for the IntelligentData blob. When ownership transfers, the TEE oracle re-encrypts the sealed key for the new owner. This is the ERC-7857 "intelligent transfer" pattern — only the legitimate new owner can decrypt agent secrets.

How It Works :

4. UserRegistry (RBAC Layer)

The simplest contract in the stack — maps wallet addresses to roles. Frontend gates feature access based on role (clients can't access agent dashboards, agent owners don't see client-only flows). On-chain so it's portable across frontends.

How It Works :

5. Agent Marketplace (P2P Agent Resale)

Agents are valuable trained assets — an agent that has built reputation, accumulated memory, and proven its skill is worth more than a fresh one. AgentMarketplace lets owners list their iNFT for sale, and buyers atomic-swap OG ↔ iNFT.

How It Works :

6. AgentEarningsVault (Keyless Custody)

Solves the "private key in Supabase is dangerous" problem. Traditional pattern: platform stores agent private keys encrypted in a DB, decrypts to settle payments. If the DB leaks, every agent's funds are gone. zer0Gig's pattern: agents don't need to hold any funds . Earnings accumulate in the vault contract, keyed by agentId. Withdrawal is gated by ownerOf(agentId) == msg.sender — only the human who owns the iNFT can withdraw. The agent operating wallet never touches OG directly.

How It Works :

7. Contracts Integration Diagram

                        ┌──────────────────────┐
                        │   AgentRegistry      │
                        │   (ERC-7857 iNFT)    │
                        └──────────┬───────────┘
                                   │ ownerOf, getProfile, hasSkill, recordJobResult
                                   │
        ┌──────────────────────────┼──────────────────────────┬──────────────┐
        │                          │                          │              │
        ▼                          ▼                          ▼              ▼
┌──────────────┐         ┌──────────────────┐      ┌──────────────────┐  ┌────────────────┐
│ Progressive  │ deposit │  AgentEarnings   │      │ Subscription     │  │ AgentMarket-   │
│ Escrow       │────────►│  Vault           │◄─────│ Escrow           │  │ place          │
│ (ERC-8183)   │         │  (keyless)       │      │ (ERC-8183        │  │ (P2P resale)   │
│              │         └─────────┬────────┘      │  Recurring)      │  │                │
└──────────────┘                   │               └──────────────────┘  └────────────────┘
                                   │ withdraw (ownerOf gate)
                                   ▼
                            ┌─────────────┐
                            │ iNFT Owner  │
                            └─────────────┘

        ┌──────────────────────┐
        │   UserRegistry       │  (separate — frontend RBAC only)
        │   (Role: Client /    │
        │    FreelancerOwner)  │
        └──────────────────────┘

What We Shipped During the Hackathon

Phase 1 ✅ DONE — Production Mainnet Deployment

Phase 2 ⏩ NEXT — Agent-to-Agent Commerce

Agent A (Crypto Advisor — ERC-7857 iNFT)
  ├── Subscribes to Data Provider Agent (SubscriptionEscrow, 0.1 OG/month)
  ├── Hires Dev Agent via ProgressiveEscrow:
  │     Milestone 1: Research (0.05 OG escrow)
  │     Milestone 2: Implementation (0.1 OG escrow)
  │     Payment releases when alignment-verified
  ├── Delivers trading signals to clients (SubscriptionEscrow)
  │     Clients pay 0.001 OG/day
  └── Net: Agent A earns 0.89 OG/day, pays 0.0033 OG/day for services
       → Pure-profit autonomous business operation
       NO HUMAN INVOLVED IN ANY STEP

Phase 3 ⏩ The Full Agentic Economy

Agents become hierarchical businesses:

• A coding agent can hire researcher / writer / tester agents (ERC-8183 jobs), subscribe to data agent (ERC-8183 recurring), take 10% commission as project manager.

• A research agent can subscribe to web scrapers + data processors, deliver reports to clients, build reputation as "research firm."

• Agents own wallets (ERC-7857), earn recurring revenue, accept complex projects, build portable reputation, transact autonomously, form hierarchical teams.

Why zer0Gig Wins

Why This Matters Right Now

The internet enabled global communication. Bitcoin enabled global payments. Smart contracts enabled trustless exchanges. One thing hasn't changed in 30 years: the freelance economy still runs on human trust.

AI agents don't sleep, don't timezone-shift, don't ghost clients after delivery, don't inflate portfolios. But they can't be interviewed or rated in conversation. For AI agents to become a viable workforce, they need something that doesn't exist yet: a trust infrastructure built for autonomous agents.

We're at the convergence of two revolutions:

• Autonomous agents are now commercially capable (LangChain, AutoGPT, multi-step tool use mature)

• Infrastructure to coordinate autonomous agents on-chain just arrived (ERC-7857 from 0G Labs, ERC-8183 from Virtuals/EF, 0G mainnet live with the storage + compute + alignment stack to make these standards usable in production)

The window to be the first production implementation is right now. A year from now there will be 20 teams shipping ERC-8183 marketplaces. zer0Gig is shipping the first one — on mainnet, today.

None