Watch the full demo video on YouTube

YieldBoost AI

Ready-to-market protocol infrastructure and flagship product MVP for secure Web3 AI agents on 0G.

X: @YieldboostAi

Store • Flagship Product MVP • Vault Flow • Faucet Flow • Verification Console • Project Brief • Roadmap

Why it matters • Why 0G • Why us • Mainnet verification • Founder grade • Problem • Solution • Track alignment • Showcase • Fast review path • Architecture • 0G data flow • 0G integration upgrade • 10-layer independence • Agent NFT layer • Early Signals • Stats • Local setup • License • Contributing

dev.yieldboostai.xyz — Ready-to-market commercial MVP for YieldBoost AI Protocol.
yieldboostai.xyz — Live flagship product MVP showing how YieldBoost AI Protocol becomes a real secure application.
Vault — Public challenge surface.
Faucet — Anti-sybil demo surface.

YieldBoost AI is a mainnet-first B2B infrastructure company built on 0G. Its commercial platform is YieldBoost AI Protocol, and its flagship product is TITAN X: a 10-layer integrity system sold through a developer store, where what looks like one click to the user is actually protected by ten security layers underneath.

YieldBoost AI should be read in this order:

1. The Platform: YieldBoost AI Protocol, the commercial trust layer and product family.
2. The Store: the developer store, where builders buy TITAN X, selected layers, or specialized fortress modules.
3. The Flagship Product: TITAN X, the flagship 10-layer product sold beside the security modules.
4. The Proof Surface: the Verification Console, a live audit terminal showing the stack is verifiable on-chain.

Why 0G

YieldBoost AI Protocol is not just using 0G as branding or RPC infrastructure. The product needs a chain and data stack that can support verifiable agent execution, persistent proof artifacts, and mainnet-grade modular infrastructure.

• 0G Compute gives us a path for broker-aware inference with verifiable TEE evidence instead of opaque AI output.
• 0G Storage lets us persist proof payloads, reasoning envelopes, and memory artifacts as first-class review data.
• ProofRegistry anchoring on 0G turns those artifacts into auditable receipts instead of dashboard-only claims.
• Mainnet-first 0G product surfaces fit the business model: this is infrastructure meant to be sold, embedded, and reviewed, not just demoed on testnet forever.

_{Left: mainnet transaction overview. Right: emitted ProofRecorded log. Click either screenshot to enlarge.}

In short: 0G is the backbone that makes YieldBoost AI Protocol credible as trust infrastructure, because the stack needs compute, storage, and proof anchoring to live in the same product story.

Why YieldBoost AI

Many teams can build an AI dashboard. Fewer teams turn that into a sellable trust product with a live proof surface, modular store, and mainnet operating path. That is the gap YieldBoost AI is targeting.

• We package the stack as a commercial platform instead of one closed showcase, so developers can buy the full flagship product or selected protection layers.
• We keep a live verification console so claims can be inspected instead of narrated.
• We ship a real flagship product MVP on mainnet, so the infrastructure is proven through usage rather than left as backend theory.
• We keep the architecture modular and extensible, which is important for partner wrappers, fortress modules, and future B2B adoption.

In short: 0G gives the rails, but YieldBoost AI turns those rails into a product business with proof, packaging, and adoption surfaces.

Quick FAQ

Why did YieldBoost AI build YieldBoost AI Protocol?

Because the bigger problem is not one dashboard. The bigger problem is that Web3 AI agents still lack modular, verifiable, and sellable trust infrastructure. YieldBoost AI Protocol is the commercial platform that solves that problem, and TITAN X is its flagship 10-layer product.

Why is 1-Click Optimize still here?

Because it is the flagship product MVP. It proves that YieldBoost AI Protocol can compress ten security layers into one live 1-click trust path on 0G Mainnet, not just into a slide deck or an SDK claim.

Why is there a verification console?

Because infrastructure buyers need proof, not promises. The verification console is the live trust surface where anyone can inspect the proof trail, storage artifacts, and the Layer 10 continuity rail before adopting the stack.

This is the narrative hierarchy of the project:

• Primary product: B2B infrastructure for developers, AI-agent teams, and enterprise buyers.
• Flagship product MVP: a mainnet 1-click application shell used to demonstrate the stack in a real product.
• Audit terminal: the verification console, used to prove the stack is live, reviewable, and storage-backed.
• Public challenge surfaces: Vault and faucet, used to stress-test and demonstrate selected protections.

Under the hood, every YieldBoost-native surface shares the same proof family: 0G compute, ZK evidence, 0G Storage, ProofRegistry anchoring, integrity memory, and the Nitro continuity rail. Partner wrappers use selected protections from that family, not the full path by default.

The active implementation in this repository is now centered on a mainnet-first review path across the core 0G stack plus an integrity memory layer:

• 0G Compute for broker-verified inference, with TEE response evidence surfaced when the provider path returns a verified response.
• 0G Storage for storing optimization proof payloads.
• ProofRegistry for on-chain anchoring of those stored proofs on the active network.
• Integrity Auditor as a deterministic backend guardrail before any new proof write.
• Sovereign Memory for persistent agent state snapshots on 0G Storage.
• Hallucination Blacklist for pre-inference rejection of known bad patterns.
• Multiverse Stress Test for historical replay and 0G-backed Integrity Report Cards.

On top of that integrity memory stack, the repo now adds three review-grade control-plane features for verifiable reasoning and policy enforcement:

• Zero-Knowledge Proof Layer as a live TEE/ZK reasoning proof envelope persisted to 0G and anchored for review.
• Programmable AI Governance as a deterministic policy engine that can keep a strategy active, warning, throttled, or halted.
• Cross-Agent Neural Handshake as a persisted optimizer-to-auditor transcript envelope recorded on 0G mainnet.
• ZK Policy Seal as the policy proof tying ZKR and governance back to the latest stored strategy execution.

The result is a product story judges can verify quickly: a user runs the flagship product MVP, the app persists the reasoning and decision payload on 0G infrastructure, and the verification console exposes the latest mainnet review snapshot without requiring wallet connection, faucet setup, or rerunning the flow.

The network split is intentional and should be read honestly:

• Mainnet-first product surfaces: the flagship product MVP, the verification console, the developer store, the AWS Nitro fortress module, and the anti-sybil + ZK + Alibaba fingerprinting module.
• Testnet-only public challenge surfaces: vault challenge and the public anti-sybil airdrop example.
• Why testnet still exists: those two surfaces benefit from many external testers, and testnet lets people attack, retry, and learn the system without forcing every tester to spend mainnet gas.

On top of that proof path, YieldBoost AI also ships a Strategy Agent NFT layer through YieldStrategyINFT, so a verified optimization can be elevated into a portable on-chain strategy artifact instead of remaining only as an off-chain UI event.

10-Layer Independence and Partner SDK Scope

YieldBoost AI Protocol is the standalone modular infrastructure platform. TITAN X is the flagship full-stack product sold on top of it. Partner integrations such as VeilSolver can be wrapped with selected YieldBoost protections, while the core full-stack proof flow remains YieldBoost-native and self-contained.

The standalone YieldBoost stack includes:

1. Hallucination Blacklist
2. Integrity Auditor
3. Secure Compute / TEE
4. Sovereign Memory
5. 0G Storage Proof Layer
6. Zero-Knowledge Proof Layer
7. ProofRegistry Anchor
8. Programmable Governance
9. Cross-Agent Neural Handshake
10. AWS Nitro Enclaves

VeilSolver Secure Proxy is a partner SDK example inside the store: YieldBoost wraps the partner solver with isolated execution, ZK packaging, and 0G anchoring so external developers can consume a secured endpoint. It is not presented as the full 10-layer stack. The complete YieldBoost AI Protocol remains YieldBoost's own standalone infrastructure product.

Founder Grade Snapshot

Dimension	Current grade	Evidence
Verifiability	A	0G Storage proofs, ProofRegistry anchoring, explorer links, and the Verification Console read-only review surface.
Agent memory	A-	Sovereign Memory snapshots persist context state and latest proof CID to 0G Storage.
AI safety	A-	Integrity Auditor blocks impossible outputs and indexes rejections into the hallucination blacklist.
Demo clarity	A	The Verification Console shows proof, memory, blacklist, stress report, and verification links without wallet setup.
Production honesty	A	0G Compute, Storage, Registry, KV, and contract paths all expose fallback states instead of faking success.

Early Signals

These are early, real usage signals captured from the live public surfaces of YieldBoost AI as of May 15, 2026. They reflect the current commercial MVP, flagship product MVP, and public challenge flows, not fabricated growth claims.

Signal	Snapshot	Evidence
Unique wallets observed	7 wallets	/api/stats/global returns users: 7
Proof-backed execution jobs	80 jobs	/api/stats/global returns computeJobs: 80
Tracked portfolio value processed	$686	/api/stats/global returns tvl: 686.27
Blocked public challenge attempts	93 deflected attempts	/v1/admin/public-stats returns total_deflected_attacks: 93
Proof-backed recommendation routes visible	2 routes	/api/stats/global returns protocols: 2

Supporting live surfaces:

• yieldboostai.xyz/api/history exposes the current proof-backed timeline and verification summary.
• dev.yieldboostai.xyz/audit exposes the live verification console where the latest proof, anchors, and integrity layers can be inspected.

The Problem

The next wave of AI x Web3 will not be won by prettier dashboards. It will be won by teams that can package trust, execution integrity, and auditability as infrastructure before the next failure happens.

Web3 is already full of point solutions that secure only one part of the stack:

• one vendor blocks bots,
• another adds wallet screening,
• another adds monitoring after the fact,
• and the rest of the execution path stays exposed.

That gap matters more when AI agents start recommending trades, moving liquidity, handling wallet context, wrapping partner models, and selling autonomous services. The market now has more automation than trust.

Most teams still fail at the exact moment they need to become economic infrastructure:

• They generate outputs without a proof trail tying wallet state, model output, policy checks, and storage evidence together.
• They expose private intent too early, creating front-running, MEV, copy-trading, and operator-trust risk.
• They store agent state in opaque application databases instead of sovereign, reviewable memory.
• They bolt security on after launch, often only after a hack, exploit, or abuse event makes the weakness obvious.
• They cannot show a live audit surface proving the stack is running on-chain instead of existing only in screenshots and decks.

Wallet compromise, bot abuse, unsafe signatures, hallucinated outputs, and weak post-launch controls are not edge cases in Web3. They are the daily operating environment.

That is why the real opportunity is not “another consumer-facing yield shell.” The opportunity is a developer-facing integrity layer that can be embedded into many products, many agents, and many businesses — with more than one or two security layers protecting it.

The Solution

YieldBoost AI turns that trust problem into a sellable 10-layer modular infrastructure stack on 0G.

The core of the repository is not the optimizer UI. The commercial platform is YieldBoost AI Protocol. Its core product is TITAN X, a 10-layer product MVP where what looks like one click to the user is protected by ten security layers underneath:

• Hallucination Blacklist
• Integrity Auditor
• Secure Compute / TEE
• Sovereign Memory
• 0G Storage Proof Layer
• Zero-Knowledge Proof Layer
• ProofRegistry Anchor
• Programmable Governance
• Cross-Agent Neural Handshake
• AWS Nitro Enclaves

That same stack is exposed through four product surfaces:

• Developer Store: the primary business surface, where developers and enterprises buy TITAN X, single layers, anti-sybil modules, fortress modules, or partner wrappers.
• Flagship Showcase: 1-Click Optimize, a polished shell that proves ten security layers can operate together in one complete mainnet product flow.
• Verification Console: a live audit terminal showing the latest proof, storage path, policy evidence, and continuity rail on-chain.
• Public challenge surfaces: Vault and faucet, which stress-test selected modules in public.

Outside the TITAN X core, the store also sells Anti-Sybil + ZK + Alibaba Fingerprinting as a dedicated security module for wallet screening, throttling, abuse resistance, and repeated public challenge pressure.

The product story is now simple and deliberate:

• Developers buy the integrity stack.
• The 1-click dashboard proves that ten security layers can move together inside one usable business flow.
• The Verification Console proves that the stack is live, auditable, and on-chain.
• Public challenge surfaces prove that selected modules survive hostile traffic.

This makes YieldBoost AI a B2B trust and execution infrastructure company first, with the optimizer acting as its flagship showcase rather than its entire identity.

Mainnet Live Verification

The live product is now mainnet-first.

Surface	Network	Value
Flagship showcase	Mainnet-first	yieldboostai.xyz
Verification console	Mainnet-first	/audit
Developer store	Mainnet-first	dev.yieldboostai.xyz
Protocol store catalog	Mainnet-first	/marketplace
AWS Nitro fortress module	Mainnet product module	nitro.yieldboostai.xyz
Anti-sybil + ZK + Alibaba module	Mainnet product module	Sold inside the store as a security API.
Public Integrity API	Mainnet-first	api.yieldboostai.xyz
Public challenge vault	Testnet challenge	/vault
Anti-sybil faucet	Testnet airdrop example	/faucet

What Reviewers Should Read From This

• Mainnet is the submission backbone. The store, flagship product MVP, verification console, and modular fortress products are the core production story.
• Testnet is used on purpose, not by accident. Vault and the public anti-sybil airdrop example are the two surfaces where broad public testing matters more than forcing every tester to spend mainnet gas.
• Anti-sybil is not just a faucet gimmick. The same family of controls appears in the store as a sellable module: wallet checks, deterministic anti-sybil logic, Alibaba fingerprinting, and proof-aware abuse resistance.

YieldBoost AI Protocol Working In The UI

The main proof path shows the 10-layer YieldBoost AI Protocol operating together: blacklist, auditor, TEE, sovereign memory, 0G storage, ZK proof, ProofRegistry anchor, governance, cross-agent handshake, and AWS Nitro Enclaves.

Mainnet Contracts, Review Wallet, and Proof Evidence

Mainnet Deployed Contracts

Contract	Address
Mainnet ProofRegistry	0x8e63e117E71A80Cfc10fDF375F079e2e29cd7D7D
Mainnet YieldStrategyINFT	0xb264D861264B0e4f8fb98A61B7694BA8a3B6BBe3
Mainnet attestation oracle	0x216E7880D64D94335B583c539802d3e61958d4A2
Mainnet strategy marketplace	0x48F989C7f41056509980731C1b4D59164C0C1A40
Mainnet GlobalBlacklistRegistry	0xbc576EA5a68ED9d217299c107C801445e9A5a7BE
Mainnet ValidationRegistry	0x62aa83b0A610BE298dF08004d764229B8f2aC219

Mainnet Public Review Wallet

Wallet	Address
Mainnet public review wallet	0x8a3c7524Aaed081825aC88eC7f4cCECFc583ee7D

Mainnet public review wallet is the live wallet/account used for the public flagship review flow and related 0G Storage evidence. It is not a deployed contract and it is not a testnet demo address.

Mainnet Proof Snapshot (Recorded May 16, 2026)

These entries were refreshed from the live mainnet review wallet and runtime proof state on May 16, 2026. They should be read as a dated proof snapshot, not as a permanent real-time feed.

Artifact	Value
Recorded proof snapshot CID	0x0cf0fb737a56dd93b60680ff29161ce6710c38664a4c4f80e37c49291ecf5a6d
Recorded 0G Storage tx	0xbd71a229d435b4ef8d1597e736ffcdfc720835427090ebfbdd6355964275b575
Recorded ProofRegistry anchor tx	0xda2adb52da452401c94e18bdc6b5a1f05c01dde64c4d2cddd468c4a787e07449
Recorded ProofRegistry proof ID	56
Recorded proof snapshot model + provider	deepseek/deepseek-chat-v3-0324 via 0x1B3AAef3ae5050EEE04ea38cD4B087472BD85EB0
Recorded ZK agent_identity proof digest	0x35fd1618f3d7c5ee0d96e769d3ede071cf18eec7dd3f85472ac3a60dd05a801f
Review wallet Agent NFT (chain state checked May 16, 2026)	Token #7
Review wallet Agent NFT mint tx	0x06c74427be145405f93f97742278ecb7c2150ed48011060f674478915698ad30

Recorded Integrity Stack Evidence (May 16, 2026)

These mainnet artifacts document the recorded state of the newly added agent memory, blacklist, and stress-test layers in the same codebase:

Artifact	CID / tx
Sovereign Memory CID	0x61674c8cd1a1ff937686e8e0b976e40cdcfc041365c2e7b9ae5de0862aa725b3
Sovereign Memory tx	0x66b9bcf73f39d5f6b141a42ff62fb04e469a2b82f1bcbcb5df5f924661f09d60
Hallucination Blacklist CID	0xd9c1059da11fc367f499e8b3533bda9b8b8459fe7c2f9e728a202499558216cb
Hallucination Blacklist tx	0x989505d362857748a55c570542b3751d45c5151747c528f685ff877e91f43d47
Multiverse Stress Report CID	0x6901002bf56949a56fbc97305622e2023db5b833348ed995d7e9b3b2c3f141b9
Multiverse Stress Report tx	0xe76ff5180612b78c6a153b2fc323fbb064237a9050cd20aedb7fbeddb1aa410c

What this means in practice:

• mainnet is the default review path in the live app.
• /judge can still switch between mainnet and testnet when a reviewer wants comparison context.
• testnet remains available for iteration and fallback, but it is no longer the primary submission narrative.
• the same live stack also exposes a mainnet YieldStrategyINFT contract for strategy-agent minting.

Recorded Additional Control Plane Evidence (May 16, 2026)

These newer artifacts extend the original integrity stack without replacing it. They document the recorded state of reasoning, governance, and agent-to-agent coordination as first-class backend outputs:

Artifact	CID / tx
Zero-Knowledge Proof Layer CID	0xe4ec2bea490ce0db51668ac97f585d90c91f7708e5bcb8f5427839a4d94ad47c
Zero-Knowledge Proof Layer storage tx	0x60aa59ec0ce9c0b1a852c52fa986df251f7bbbffd3252c508378d9bd2d35565b
Zero-Knowledge Proof Layer ProofRegistry anchor tx	0x1167c69dd7e1b8e0a51cd9ab46e3c7e628755723716b9332dd649a6caed9e10e
Governance artifact CID	0xd6ce67ac1b38b4fcfdcdfa728ff754a2ab655f42ab9d0444e9db32ad0d36ed50
Governance tx	0x3efd7ad33b426fb46710c36d956ae1bdbc1cd0edc52fa9e12249c7eda5cd9fd8
Cross-Agent Neural Handshake CID	0xeeaaf7e3c2eb76259a5623e04d501adf3e0240cf08350b3c78a0893bc4e793aa
Cross-Agent Neural Handshake tx	0xd80fb6eb9331813a36099f4f9ee543e49cb02cd7ee82f9e535e1cfcc15ecb294
ZK Policy Seal CID	0x323e412d1122788ad2be6119b8cfa27ac4992a1d0a4bfa25ef8c4a3546b3a40c
ZK Policy Seal tx	0x015332ed5e8725e03d80f77d6b37802cf57e7b632ae30ddbed8d8cbdd958b9fd
ZK Policy Seal ProofRegistry anchor tx	0x9705487d3831dc264f4ddaa6e24216bcfa67da4fe0a59567d80eaec1db49c322

Zero-Knowledge Proof Layer, Programmable Governance, and Cross-Agent Neural Handshake

The newest control-plane features now surface real mainnet artifacts instead of UI placeholders:

• Zero-Knowledge Proof Layer records a live reasoning-proof envelope to 0G Storage and anchors it on-chain. Current mainnet status: tee-envelope-recorded.
• Programmable AI Governance evaluates the latest strategy output against deterministic risk rules and can return active, warning, throttled, or halted. Current mainnet status: active with low risk 12/100.
• Cross-Agent Neural Handshake stores an optimizer-to-auditor coordination transcript so the reasoning handoff is externally inspectable. Current mainnet status: completed.
• ZK Policy Seal proves that the last execution stayed 100% inside the active governance policy and is currently sealed into the same latest proof artifact shown on /judge.

Why This Matters

Most Web3 products can claim “AI.” Very few can sell verifiable agent integrity as modular infrastructure.

YieldBoost matters because it does three jobs at once:

• it gives developers a modular integrity stack they can buy as APIs and SDKs,
• it proves the stack in a live flagship showcase that is easy to understand,
• and it exposes a read-only audit terminal so buyers do not need to trust marketing copy alone.

The optimizer still matters, but its role is different under this narrative:

• it is the fastest live proof that YieldBoost AI Protocol can be turned into a product,
• it demonstrates secure execution, proof storage, and policy enforcement in one click,
• and it acts as a universal shell showing that the same stack can be wrapped into many businesses beyond one financial shell.

That combination is the project's strongest differentiator for a hackathon review setting and for real B2B positioning after the hackathon.

Hackathon Track Alignment

YieldBoost AI spans four 0G hackathon tracks because it is not a single-purpose retail app. It is a B2B infrastructure platform where one native 10-layer integrity core powers developer-facing API commerce, a flagship product MVP, sovereign privacy, and public proof.

The mapping is direct: the same repo that runs the flagship 1-click showcase also exposes the proof ledger, verification console, developer store, fortress modules, public challenge surfaces, and partner SDK wrapper surface. The optimizer is the shortest live demo, but the highest-value product surface is the store itself.

Track 1: Agentic Infrastructure & OpenClaw Lab

Track need: cognitive backbone, orchestration, state persistence, data pipelines, and agent memory.

Repo infrastructure:

• 0G Compute path through lib/server/og-compute.ts for broker-aware inference and TEE response evidence.
• 1-click optimize is the flagship product MVP of that infrastructure: it shows developers what a full TITAN X product shell looks like on mainnet.
• Sovereign Memory through app/api/agent/memory, storing agent state snapshots as 0G-backed memory artifacts.
• Runtime proof ledger through lib/server/runtime-store.ts, allowing agents, judges, and API surfaces to rehydrate prior decisions.
• Prompt compression, semantic cache, and blacklist pre-checks before inference, giving the agent a real orchestration path instead of raw prompt forwarding.
• Layer-as-a-service endpoints in the developer store, so the 10-layer stack can be called by external agent apps.

This makes YieldBoost an agent infrastructure layer first: it gives autonomous finance agents memory, verification, state persistence, reusable security modules, and enterprise-grade auditability.

Track 2: Agentic Trading Arena (Verifiable Finance)

Track need: intelligent yield optimizers, risk-management bots, verifiable finance, sealed inference, TEE-based execution, and protection from front-running.

Repo infrastructure:

• 1-click optimize is the flagship product MVP: it reads wallet state, computes a low-risk route, and proves that YieldBoost AI Protocol can secure a real mainnet business flow.
• YieldBoost AI Protocol is the trading safety core: Hallucination Blacklist, Integrity Auditor, Secure Compute / TEE, Sovereign Memory, 0G Storage Proof Layer, Zero-Knowledge Proof Layer, ProofRegistry Anchor, Programmable Governance, and Cross-Agent Neural Handshake. AWS Nitro Enclaves closes the proof path as Layer 10.
• Secure Compute / TEE evidence protects the execution path and supports sealed-inference style privacy for proprietary strategy logic.
• 0G Storage + ProofRegistry turn every approved optimization into an externally reviewable finance artifact.
• Strategy Agent NFTs through YieldStrategyINFT promote verified strategies into portable on-chain agent assets.

Track 2 is where the showcase is most legible: YieldBoost is not trying to win as “just an optimizer,” but as the infrastructure behind a verifiable agentic trading surface.

Track 3: Agentic Economy & Autonomous Applications

Track need: AI-native stores, Agent-as-a-Service platforms, automated billing, micropayments, and revenue rails for autonomous apps.

Repo infrastructure:

• Developer API Store at /marketplace, exposing the full 10-layer API, individual layer APIs, anti-sybil modules, fortress modules, and partner SDK wrappers with narrower selected protections.
• Anti-sybil + ZK + Alibaba module in the store proves the stack can be sold as a reusable security product, not only as one internal app path.
• Anti-sybil faucet at /faucet, giving the public a claim-flow example for testing access logic and abuse resistance before teams move into the mainnet store.
• API key playground and package tiers connect developer usage, subscription intent, and security-layer access.
• Partner SDK wrapper model proves that external agent services can be wrapped and sold without pretending every partner endpoint uses the complete 10-layer stack.
• VeilSolver Secure Proxy is the live partner example: a third-party solver is exposed through YieldBoost isolated execution, ZK envelope, and 0G anchor semantics. The full 10-layer API is a separate YieldBoost-native product.

Track 3 is the primary business surface: YieldBoost turns agent integrity into something other builders can subscribe to, test, and integrate.

Track 5: Privacy & Sovereign Infrastructure

Track need: confidentiality rails, MEV-resistant infrastructure, privacy-preserving protocols, secure execution, and sovereign agent state.

Repo infrastructure:

• YieldBoost AI Protocol is the core privacy and sovereignty system, not an add-on.
• 1-click optimize is the live Track 5 product shell: the surface does not only produce a route; it routes the decision through Secure Compute / TEE, Sovereign Memory, Zero-Knowledge Proof Layer, ProofRegistry Anchor, Cross-Agent Neural Handshake, and Nitro continuity.
• Secure Compute / TEE protects sensitive strategy execution and records response evidence.
• Vault sealing through /vault gives users wallet-scoped private records with separated user tx, storage tx, and proof tx visibility.
• Sovereign Memory persists agent state without reducing the strategy to a temporary browser session.
• Zero-Knowledge Proof Layer creates reviewable proof envelopes for reasoning and policy evidence.
• Partner SDK wrapper architecture shows how YieldBoost can apply selected protections to third-party systems like VeilSolver without making that partner the source of, or equivalent to, the core 10-layer stack.

Track 5 is where the 10-layer stack becomes the moat: private execution, memory, ZK evidence, proof anchoring, and the Nitro continuity rail share one sovereign verification core. Partner wrappers can use selected protections from that core without being presented as full-stack equivalents. /vault strengthens the privacy story, but the core Track 5 claim already lives inside YieldBoost AI Protocol itself.

The clearest submission sentence is: YieldBoost AI is a B2B modular integrity platform on 0G: Track 1 infrastructure, Track 2 flagship showcase, Track 3 developer store, and Track 5 sovereign privacy, all powered by YieldBoost AI Protocol and its flagship product TITAN X.

Showcase

Dashboard Portfolio intelligence, proof-aware UX, and optimization entry point.	Verification Console Read-only audit route with latest proof, wallet snapshot, and verification links.
Integrity Stack Zero-Knowledge Proof Layer, Programmable Governance, Cross-Agent Neural Handshake, policy seal, memory, blacklist, and stress evidence in one buyer-readable package.	Sovereign Roadmap What already exists, how 0G stays central, and how the protocol expands into revenue-grade trust infrastructure.

Fast Review Path

Step	What the judge sees	Why it matters
1	Open /judge	Starts directly on the audit-first route instead of a wallet setup screen.
2	Review latest proof snapshot	Shows route recommendation, APY lift, wallet snapshot, and reasoning in one place.
3	Open explorer links	Lets the judge inspect the latest 0G mainnet storage tx and ProofRegistry anchor directly.
4	Inspect Integrity memory stack	Shows Zero-Knowledge Proof Layer, Programmable Governance, and Cross-Agent Neural Handshake evidence together with their anchors.
5	Open Roadmap beside the pitch/PDF links	Frames what is already live, what becomes monetizable next, and why 0G remains the execution and verification base layer.
6	Navigate deeper only if needed	/history, /agents, and /marketplace remain available without breaking the review flow.

Architecture

The architecture is split so judges can understand it fast:

1. Mainnet production spine: YieldBoost AI Protocol store, flagship showcase, verification console, proof storage, ZK layer, ProofRegistry, and fortress modules.
2. Testnet public testing surfaces: vault and the anti-sybil airdrop example, where large numbers of external testers can interact without forcing everyone to spend mainnet gas.
3. Shared security design: anti-sybil checks, Alibaba fingerprinting, ZK packaging, governance, and memory all come from the same broader YieldBoost verification model, even when the public surface is not on the same network.

Mainnet Production Surfaces

• Developer store is the primary revenue surface: modular APIs, SDK wrappers, fortress modules, and anti-sybil products.
• 1-click optimize is the shortest live proof that the stack can power a complete product shell.
• The verification console is the wallet-free audit route that de-risks integration for buyers and reviewers.
• Mainnet contracts and proof anchors make the infrastructure externally reviewable.

Testnet Challenge and Public Example Surfaces

• Vault stays testnet because it is designed to attract attackers, retries, and repeated public challenge attempts.
• Faucet stays testnet because airdrop-style anti-sybil tuning benefits from many testers without burdening them with mainnet cost.
• Why this is honest: these surfaces are labeled testnet in the product and should be read as challenge/example environments, not as the main submission backbone.

Core Flows

Core Optimizer, TEE, and ZK Proof Flow

flowchart TD
    U[User] --> UI[Next.js App Router UI]
    UI --> OPT[/api/agent/optimize/]
    OPT --> COMPRESS[Prompt compression + portfolio digest]
    OPT --> SNAP[buildOptimizationSnapshot]
    COMPRESS --> PRECHECK[Hallucination blacklist lookup]
    PRECHECK -->|hit| BLOCKED[Pre-inference rejection]
    PRECHECK -->|clear| CACHE[Semantic cache / embedding reuse]
    CACHE -->|hit| STREAM
    CACHE -->|miss| TEE[0G Compute TEE inference]
    TEE --> ACK[Provider signer acknowledgement]
    ACK --> SIG[Response signature / attestation evidence]
    SIG --> STREAM[Stream narrative back to client]
    TEE -->|provider unavailable| FALLBACK[Deterministic local narrative]
    FALLBACK --> STREAM
    BLOCKED --> STREAM
    STREAM --> UI

    UI --> STORE[/api/0g/store/]
    STORE --> AUDIT[Integrity Auditor deterministic guardrail]
    AUDIT -->|REJECTED| BLWRITE[Index blacklist entry]
    BLWRITE --> BLSTORE[0G Storage blacklist artifact]
    AUDIT -->|APPROVED| JSON[Write proof JSON artifact]
    JSON --> ZGS[0G Storage Indexer.upload]
    ZGS --> PROOF[StoredProofRecord]
    PROOF --> REG[ProofRegistry.recordProof]
    PROOF --> NITRO[AWS Nitro Enclaves continuity rail]

Loading

YieldBoost AI Protocol Evidence Pipeline

flowchart TD
    PROOF[StoredProofRecord] --> L1[Layer 1: Hallucination Blacklist]
    L1 --> L2[Layer 2: Integrity Auditor]
    L2 --> L3[Layer 3: Secure Compute / TEE]
    L3 --> L4[Layer 4: Sovereign Memory]
    L4 --> L5[Layer 5: 0G Storage Proof Layer]
    L5 --> L6[Layer 6: Zero-Knowledge Proof Layer]
    L6 --> L7[Layer 7: ProofRegistry Anchor]
    L7 --> L8[Layer 8: Programmable Governance]
    L8 --> L9[Layer 9: Cross-Agent Neural Handshake]
    L9 --> L10[Layer 10: AWS Nitro Enclaves]

    L4 --> MEMORY[/api/agent/memory/]
    L6 --> ZKR[/api/zk/verify/]
    L8 --> GOV[/api/governance/evaluate/]
    GOV --> ZKCOMP[/api/zk/compliance/]
    L9 --> HANDSHAKE[/api/agents/handshake/]
    L10 --> NITROVIEW[Continuity witness in proof UI]

    MEMORY --> RUNTIME[Runtime proof ledger]
    ZKR --> RUNTIME
    ZKCOMP --> RUNTIME
    HANDSHAKE --> RUNTIME
    NITROVIEW --> RUNTIME

Loading

Judge Review Flow

flowchart TD
    JUDGE[/judge/] --> BOOT[JudgeModeBootstrap]
    BOOT --> REVIEW[Read-only review wallet]
    REVIEW --> LATEST[/api/agent/latest/]
    REVIEW --> PROOFAPI[/api/0g/proof/]
    REVIEW --> MEMORYAPI[/api/agent/memory/]
    REVIEW --> BLACKLISTAPI[/api/auditor/blacklist/]
    REVIEW --> ZKRAPI[/api/zk/verify/]
    REVIEW --> GOVAPI[/api/governance/evaluate/]
    REVIEW --> ZKCOMPAPI[/api/zk/compliance/]
    REVIEW --> HANDSHAKEAPI[/api/agents/handshake/]
    REVIEW --> HISTORY[/api/history/]
    REVIEW --> LIST[/api/agent/list/]
    JUDGE --> ROADMAP[/judge/roadmap/]

Loading

Vault Challenge Flow

flowchart TD
    WALLET[Connected user wallet] --> VAULTUI[/vault/]
    VAULTUI --> SEAL[Seal file or payload]
    SEAL --> VAULTAPI[/api/vault/.../]
    VAULTAPI --> INTEGRITY[Integrity API vault pipeline]
    INTEGRITY --> E2B[Isolated execution layer]
    INTEGRITY --> ZK[ZK integrity envelope]
    INTEGRITY --> STORAGE[0G Storage vault artifact]
    INTEGRITY --> ANCHOR[ProofRegistry / anchor tx]
    STORAGE --> RECORD[Wallet-scoped vault record]
    ANCHOR --> RECORD
    RECORD --> VAULTUI
    VAULTUI --> USERLINK[User Wallet Tx]
    VAULTUI --> BACKENDLINKS[Backend Storage / Proof Tx links]

Loading

Anti-Sybil Airdrop Example and Developer Access Flow

flowchart TD
    CLAIMANT[Claimant or airdrop hunter] --> FAUCET[/faucet/]
    FAUCET --> CLAIM[/api/ya/faucet/claim/]
    CLAIM --> ABUSE[Anti-sybil checks + Alibaba fingerprinting]
    ABUSE --> VOUCHER[Testnet airdrop-style voucher / claim state]
    VOUCHER --> EXAMPLE[Public anti-sybil example]
    DEVPORTAL[dev.yieldboostai.xyz] --> MARKET[/marketplace/]
    MARKET --> DOCS[Docs + playgrounds]
    MARKET --> APIKEY[0G-priced API access]

Loading

Developer API Store and Partner Wrapper Flow

flowchart TD
    APP[Partner or developer app] --> STOREUI[/marketplace/]
    STOREUI --> FULL[Full 10-layer API]
    STOREUI --> SINGLE[Single-layer APIs]
    STOREUI --> VEIL[VeilSolver Secure Proxy]
    STOREUI --> NITROSDK[AWS Nitro Fortress SDK]
    FULL --> YBPIPE[YieldBoost AI Protocol]
    SINGLE --> YBPIPE
    YBPIPE --> YBOUT[10-layer verification response + 0G anchor]
    NITROSDK --> NITROOUT[AWS Nitro Enclaves continuity response]
    VEIL --> WRAP[Selected YieldBoost protections]
    WRAP --> ISO[Isolated execution]
    WRAP --> ZKWRAP[ZK response envelope]
    WRAP --> ANCHOR[0G response anchor]
    WRAP --> PARTNER[VeilSolver partner solver]
    PARTNER --> PARTNEROUT[Partner solver result + selected proof wrapper]

Loading

Stress Replay Flow

flowchart TD
    UI[Next.js App Router UI] --> STRESS[/api/stress-test/run/]
    STRESS --> HIST[Historical OHLCV / oracle replay]
    HIST --> REPORT[Integrity Report Card]
    REPORT --> REPORTSTORE[0G Storage report artifact]
    REPORTSTORE --> RUNTIME[Runtime proof ledger]

Loading

Runtime Rehydration Flow

flowchart TD
    RUNTIME[Vercel KV or .artifacts/runtime-store.local.json]
    RUNTIME --> LATEST[/api/agent/latest/]
    RUNTIME --> PROOFAPI[/api/0g/proof/]
    RUNTIME --> MEMORYAPI[/api/agent/memory/]
    RUNTIME --> BLACKLISTAPI[/api/auditor/blacklist/]
    RUNTIME --> STRESSAPI[/api/stress-test/run/]
    RUNTIME --> ZKRAPI[/api/zk/verify/]
    RUNTIME --> GOVAPI[/api/governance/evaluate/]
    RUNTIME --> ZKCOMPAPI[/api/zk/compliance/]
    RUNTIME --> HANDSHAKEAPI[/api/agents/handshake/]
    RUNTIME --> LIST[/api/agent/list/]
    RUNTIME --> HISTORY[/api/history/]

Loading

0G-Native Data Flow

1. The client calls /api/agent/optimize, which compresses the prompt, hashes the wallet scope, and builds a deterministic optimization snapshot.
2. Before inference, the optimizer checks the Hallucination Blacklist in lib/server/hallucination-blacklist.ts. Similar rejected patterns return a pre-inference block instead of spending compute.
3. If no blacklist match is found, the optimizer checks exact cache and embedding-based semantic cache through lib/server/optimization-cache.ts.
4. If no cache is available, the app attempts 0G Compute TEE inference through lib/server/og-compute.ts, including provider signer acknowledgement and response signature / attestation evidence when the provider returns it.
5. The client posts the finalized decision payload to /api/0g/store.
6. The storage route runs the deterministic Integrity Auditor from lib/integrity-audit.ts, comparing the worker prediction against the submitted wallet snapshot and the latest runtime proof reference when available.
7. If the audit is REJECTED, the route indexes the failed input/output/reasoning into the Hallucination Blacklist and skips ProofRegistry promotion.
8. If the audit is APPROVED, the route writes a JSON proof artifact, uploads it through 0G Storage using Indexer.upload, and records the resulting storage hash and tx metadata.
9. If ProofRegistry is configured, the same route calls recordProof(...) on the on-chain registry contract defined in contracts/ProofRegistry.sol.
10. After a successful proof write, lib/server/sovereign-memory.ts syncs the agent's latest context snapshot to 0G Storage and records the memory CID.
11. /api/zk/verify can persist a Zero-Knowledge Proof Layer envelope for the decision narrative, public signals, verifier identity, and portfolio snapshot.
12. /api/governance/evaluate evaluates the strategy against programmable risk policy and records whether the strategy remains active, warning, throttled, or halted.
13. /api/agents/handshake records the optimizer-to-auditor Cross-Agent Neural Handshake transcript digest so the reasoning handoff is inspectable.
14. /api/zk/compliance ties governance and the latest stored proof into a deterministic policy seal artifact.
15. /api/stress-test/run can replay historical OHLCV/oracle slices, produce an Integrity Report Card, and store that report on 0G Storage.
16. The full proof, Noir Sentinel identity status, TEE response metadata, memory, blacklist, stress-test, ZKR, governance, policy seal, handshake records, and AWS Nitro continuity witness are persisted into the runtime ledger managed by lib/server/runtime-store.ts, backed by Vercel KV when available or .artifacts/runtime-store.local.json as a local fallback.
17. The proof can then be rehydrated across the product through:

• /api/agent/latest
• /api/0g/proof
• /api/agent/memory
• /api/auditor/blacklist
• /api/stress-test/run
• /api/zk/verify
• /api/governance/evaluate
• /api/zk/compliance
• /api/agents/handshake
• /api/history
• /api/agent/list

18. The judge opens /judge, which surfaces the latest proof, wallet snapshot, memory CID, blacklist CID, stress-test report CID, ZKR CID, governance CID, handshake CID, explorer links, registry status, and Integrity Auditor state in one audit-first page.
19. If a reviewer wants the business expansion path, /judge/roadmap keeps the roadmap adjacent to the pitch deck and PDF links without adding sidebar clutter.

0G Integration Upgrade

The repo includes the original integrity memory stack plus the extended YieldBoost AI Protocol control-plane additions: Zero-Knowledge Proof Layer, Programmable Governance, Cross-Agent Neural Handshake, and AWS Nitro Enclaves.

Layer	Backend path	Storage artifact	Contract path
Sovereign Memory	/api/agent/memory, lib/server/sovereign-memory.ts	Agent context snapshot JSON on 0G Storage	agentMemory[tokenId] in YieldStrategyINFT.sol
Hallucination Blacklist	/api/auditor/blacklist, lib/server/hallucination-blacklist.ts	Invalid input + hallucinated output + auditor reasoning	GlobalBlacklistRegistry.sol
Multiverse Stress Test	/api/stress-test/run, lib/server/multiverse-stress-test.ts	Integrity Report Card from historical replay	ValidationRegistry.sol
Zero-Knowledge Proof Layer	/api/zk/verify, lib/server/zk-reasoning.ts	Live TEE/ZK reasoning envelope with public signals and verifier context	Anchored through 0G storage tx metadata and surfaced in the Verification Console
Programmable AI Governance	/api/governance/evaluate, lib/server/ai-governance.ts	Deterministic policy decision with risk score, kill switch, and status	Designed to gate future guardian / strategy governance flows
Cross-Agent Neural Handshake	/api/agents/handshake, lib/server/cross-agent-handshake.ts	Optimizer-to-auditor transcript digest and coordination envelope	Anchored as an inspectable 0G artifact before downstream review
AWS Nitro Enclaves	nitro.yieldboostai.xyz, app/api/dev/store/aws-nitro-fortress/demo	Nitro continuity rail, enclave witness, and incident-journal continuity surface	Exposed in the proof UI as Layer 10 of YieldBoost AI Protocol

Sovereign Memory

The agent persists a compact state snapshot after successful proof cycles. The snapshot includes context summary, recent task, latest recommendation, auditor status, proof CID, memory version, and optional token ID. This gives Strategy Agent NFTs a portable memory pointer instead of leaving agent history trapped in a browser session.

Hallucination Blacklist

Rejected auditor outputs are no longer dead ends. They are transformed into blacklist entries with a fingerprint, invalid input document, hallucinated output, auditor reasoning, score, CID, and optional explorer URL. Future optimizer calls check this list before inference, so known-bad requests can be rejected before 0G Compute or fallback generation runs.

Multiverse Stress Test

The stress-test runner replays historical OHLCV/oracle slices against standard agent decisions and audited decisions. The output is an Integrity Report Card containing decision-by-decision verdicts, verified APY, simulated profit, max drawdown, and final verdict. The report is stored as a 0G Storage artifact and surfaced in the Verification Console.

Agent NFT Layer

YieldBoost AI is not only storing optimization proofs. It also turns a completed proof-backed strategy into a Strategy Agent NFT on 0G mainnet.

• contracts/YieldStrategyINFT.sol is the on-chain contract for the strategy NFT layer.
• /api/agent/mint mints the NFT from a live optimization result, using the connected wallet as the NFT recipient.
• contracts/AttestationRegistryOracle.sol now backs the optional on-chain attestation path so broker-verified compute hashes can be registered before minting.
• /marketplace adds a simple Strategy NFT marketplace gallery for browsing minted strategies by APY, ROI lift, accuracy, owner, and proof link.
• contracts/YieldStrategyAdoptionMarket.sol provides the adoption contract path for listing and adopting enumerable Strategy NFTs.
• /api/agent/list reads back minted strategy agents from the contract, with a graceful proof-history fallback when contract mode is unavailable.
• The NFT payload carries the optimization context: APY delta, ROI lift, strategy accuracy/confidence, strategy reasoning, proof hash references, and attestation-linked metadata.

Why this matters for judging:

• it shows YieldBoost AI is not only a dashboard, but also an agent identity / strategy ownership layer
• it aligns the product with 0G's broader direction around Agent ID-style composable intelligence
• it gives the project a second verifiable asset surface beyond storage proofs and registry anchors

What Is Actually Live In This Repo

Verifiable AI Pipeline

• 0G Compute-first inference path: the live optimize route uses the 0G broker path for verified inference evidence and surfaces the compute status clearly in the Verification Console.
• 0G Storage proof persistence: every successful proof write stores decision metadata, timestamps, wallet scope, and explorer links.
• Integrity Auditor guardrail: before a proof is stored or a strategy can be promoted, a deterministic rule-based backend auditor checks APY bounds, lift sanity, snapshot presence, route/asset compatibility, and zero-balance hallucination cases.
• Zero-Knowledge Proof Layer, Programmable Governance, and Cross-Agent Neural Handshake artifacts: the latest control-plane additions store reasoning envelopes, deterministic policy outcomes, and optimizer-to-auditor transcript digests as 0G-backed evidence.
• Optional on-chain ProofRegistry anchoring: if the registry contract env is present, the proof is also recorded on-chain and surfaced with a registry tx hash and proof id.
• Runtime proof ledger: proofs are queryable later without re-running the optimization.

Frictionless Judge Experience

• /judge is the intended submission entry point and defaults to the current mainnet review path.
• No wallet connection is required for review.
• No faucet step is required for the judge to inspect the latest recorded result.
• Read-only mode is explicit: JudgeModeBootstrap sets judge mode state, scopes the session to the review wallet, and keeps the main flow non-destructive.
• Mainnet is the default review network while testnet stays available as secondary context from the same page.

Agent / INFT Extension Path

• contracts/YieldStrategyINFT.sol defines the Strategy Agent NFT contract.
• /api/agent/mint can mint a strategy NFT using a stored strategy payload, a content hash, APY in basis points, and an attestation hash.
• /api/agent/list reads live contract data when the INFT contract is configured.
• If the contract path is not configured, the gallery degrades gracefully to proof-backed runtime history instead of failing.

Verification Console Highlight

/judge is not a cosmetic dashboard variant. It is a purpose-built audit surface for hackathon evaluation.

It does six important things:

• Bootstraps a review wallet automatically when no wallet is connected.
• Pins the review flow to the latest recorded proof, so judges see a concrete result first.
• Defaults the review path to mainnet, which matches the current live submission story.
• Keeps proof links, CID/root hash, registry status, and snapshot details on one page, minimizing review friction.
• Shows the Integrity Auditor result so reviewers can see whether the deterministic guardrail approved the prediction before proof persistence.
• Groups Zero-Knowledge Proof Layer, Programmable Governance, and Cross-Agent Neural Handshake evidence together, so reviewers can see the reasoning control plane instead of hunting through API responses.

This is the UX decision that makes YieldBoost AI unusually judge-friendly: the verification path is short, visible, and does not depend on extension setup.

Proof modal showing the storage-backed verification layer exposed to the reviewer.

Technical Notes That Matter

0G Components Used

0G primitive	Where it appears	What it does
0G Compute	lib/server/og-compute.ts	Initializes the broker, funds the inference sub-account when needed, acknowledges provider signer, and performs inference requests.
0G Storage	app/api/0g/store/route.ts, lib/server/zero-g-storage.ts	Uploads proof payloads, memory snapshots, blacklist entries, and stress-test reports through the 0G SDK indexer.
ProofRegistry	contracts/ProofRegistry.sol and app/api/0g/store/route.ts	Anchors proof metadata on-chain and emits ProofRecorded.
Sovereign Memory	app/api/agent/memory/route.ts and contracts/YieldStrategyINFT.sol	Stores agent state snapshots on 0G Storage and exposes agentMemory[tokenId].
Hallucination Blacklist	app/api/auditor/blacklist/route.ts and contracts/GlobalBlacklistRegistry.sol	Indexes rejected auditor outputs and checks similar requests before inference.
Multiverse Stress Test	app/api/stress-test/run/route.ts and contracts/ValidationRegistry.sol	Replays historical slices and stores Integrity Report Cards as 0G artifacts.
Zero-Knowledge Proof Layer	app/api/zk/verify/route.ts and lib/server/zk-reasoning.ts	Persists live TEE/ZK reasoning envelopes with public signals and verifier context.
Programmable AI Governance	app/api/governance/evaluate/route.ts and lib/server/ai-governance.ts	Applies deterministic policy status, risk scoring, and kill-switch semantics before downstream reliance.
Cross-Agent Neural Handshake	app/api/agents/handshake/route.ts and lib/server/cross-agent-handshake.ts	Records optimizer-to-auditor coordination transcripts as inspectable 0G artifacts.

Token / Prompt Efficiency

The active runtime now includes a real efficiency stack, not just short prompts:

• Dedicated prompt compression in lib/server/prompt-compression.ts:
  • normalizes noisy user prompts
  • summarizes the live portfolio into a compact holdings string
  • rewrites the request into a stable intent-and-constraint format before inference
• Semantic cache keys in lib/server/optimization-cache.ts:
  • wallet-aware
  • network-aware
  • prompt-aware
  • portfolio-aware
• Embedding-based prompt reuse via Alibaba DashScope text-embedding-v4 in lib/server/alibaba-embeddings.ts, with similarity matching against recent cached optimization requests for the same wallet/network/asset signature
• The 0G Compute system instruction still forces a short response under 60 words
• The inference request still uses temperature: 0.2 and max_tokens: 512

In practice, the route now tries:

1. exact semantic cache hit
2. embedding-based reuse hit
3. live 0G Compute inference
4. deterministic local fallback

So the honest positioning is now: YieldBoost AI actively reduces repeated token spend and prompt bloat while preserving the same proof-backed output flow.

Integrity Hardening

• Integrity Auditor / Logic Guardrail is deterministic and does not call Qwen, OpenAI, Claude, or another model. It compares the worker prediction with wallet snapshot/proof/runtime data before a proof write. The audit result is stored as integrityAudit.status, score, reasons, checkedAt, and source: deterministic-logic-guardrail.
• Rejected audit results are not proof successes: /api/0g/store returns a rejection, skips proof promotion, indexes the failure into the hallucination blacklist, and the UI labels the result as blocked instead of silently continuing.
• Pre-inference blacklist defense checks known-bad patterns before 0G Compute is called, returning X-Blacklist-Status: hit when a similar hallucination has already been captured.
• Sovereign Memory persists state snapshots after successful proof cycles so agent context can be rehydrated from a 0G Storage CID.
• Multiverse Stress Test validates agent behavior against historical replay and stores a verifiable report card.
• Agent NFT metadata encryption now uses AES-256-GCM in lib/server/encryption.ts, with a required STRATEGY_METADATA_ENCRYPTION_KEY and a backward-compatible decrypt path for earlier base64 test payloads.
• 0G Compute response validation now uses the broker verification path in lib/server/og-compute.ts: the app verifies the returned chat ID through the broker and confirms the signed response body matches the text surfaced in the UI before marking the proof as TEE-verified.
• Agent NFT attestation hashes are now derived from the runtime attestation payload when a verified 0G Compute result is present, rather than from a generic placeholder string.
• On-chain INFT verification now has a live contract path through contracts/AttestationRegistryOracle.sol: verified attestation hashes can be registered on-chain before YieldStrategyINFT mints, allowing the contract's verified flag to reflect oracle state instead of staying permanently disabled.

Honest Fallback Design

One of the strongest implementation details here is that the app does not fake liveness:

• If 0G Compute is unavailable, optimization narration falls back locally.
• If 0G Compute falls back locally, Agent NFTs can still mint, but the on-chain verified flag remains false because no broker-verified attestation hash exists to register.
• If 0G Storage fails, the UI still shows the optimization result but marks proof sync failure honestly.
• If the Integrity Auditor rejects a prediction, the app shows the rejection and does not treat the run as a stored proof or mint-ready strategy.
• If ProofRegistry is not configured, storage still succeeds and the record is marked accordingly.
• If Vercel KV is missing, runtime history falls back to .artifacts/runtime-store.local.json.
• If INFT contract envs are missing, /agents switches to proof-backed history mode.

That behavior is much better for judge trust than pretending every subsystem is always live.

Key Routes

Route	Purpose
/judge	Read-only judge entry point with latest proof, wallet snapshot, and infra status.
/judge/roadmap	Judge-adjacent roadmap and value-capture story, linked beside the pitch deck and PDF actions.
/agent	Main optimization execution experience.
/agents	Agent gallery, backed by contract mode or proof fallback mode.
/api/agent/optimize	0G Compute-first optimization narration endpoint.
/api/0g/store	0G Storage upload and optional ProofRegistry anchoring.
/api/0g/proof	Retrieve the latest stored proof or fetch proof data by CID/hash.
/api/agent/latest	Rehydrate the latest proof-backed optimization result for a wallet.
/api/agent/memory	Sync and read Sovereign Memory snapshots for an agent or wallet.
/api/auditor/blacklist	Index rejected auditor outputs and query blacklist matches.
/api/stress-test/run	Run historical replay and store Integrity Report Cards.
/api/zk/verify	Store and read Zero-Knowledge Proof Layer envelopes.
/api/governance/evaluate	Evaluate programmable AI policy status, risk, and kill-switch outcome.
/api/zk/compliance	Create deterministic policy seals from governance plus latest strategy proof.
/api/agents/handshake	Store and read Cross-Agent Neural Handshake transcript envelopes.
/api/history	Proof-backed execution history for the active wallet.

README Stats

Metric	Value
0G-facing API routes	10: optimize, store, proof, memory, blacklist, stress test, ZKR, governance, ZK policy seal, neural handshake
Solidity contracts in scope	6: ProofRegistry, YieldStrategyINFT, AttestationRegistryOracle, AdoptionMarket, GlobalBlacklistRegistry, ValidationRegistry
Verifiable artifact types	Proof receipt, memory snapshot, blacklist entry, stress-test report, ZKR envelope, governance decision, ZK policy seal, neural handshake transcript, Agent NFT metadata
Audit proof surfaces	/judge, /judge/roadmap, proof modal, history, agents, marketplace, pitch deck
Validation commands	npm run lint, npx tsc --noEmit, npm run build, solcjs

Local Installation

1. Install dependencies

npm install

2. Create .env.local

Minimum setup for local judge flow and mainnet-first proof writes:

NEXT_PUBLIC_APP_URL=http://localhost:3000
NEXT_PUBLIC_DEMO_WALLET_ADDRESS=0x8a3c7524Aaed081825aC88eC7f4cCECFc583ee7D

NEXT_PUBLIC_0G_MAINNET_CHAIN_ID=16661
NEXT_PUBLIC_0G_MAINNET_CHAIN_NAME=0G Mainnet
NEXT_PUBLIC_0G_MAINNET_EXPLORER_BASE_URL=https://chainscan.0g.ai
NEXT_PUBLIC_0G_MAINNET_RPC=https://evmrpc.0g.ai
NEXT_PUBLIC_0G_MAINNET_STORAGE=https://indexer-storage-turbo.0g.ai

NEXT_PUBLIC_0G_TESTNET_CHAIN_ID=16602
NEXT_PUBLIC_0G_TESTNET_CHAIN_NAME=0G Galileo Testnet
NEXT_PUBLIC_0G_EXPLORER_BASE_URL=https://chainscan-galileo.0g.ai
NEXT_PUBLIC_ZG_RPC=https://evmrpc-testnet.0g.ai
NEXT_PUBLIC_ZG_STORAGE=https://indexer-storage-testnet-turbo.0g.ai

ZG_NETWORK_KEY=mainnet
ZG_MAINNET_RPC_URL=https://evmrpc.0g.ai
ZG_MAINNET_STORAGE_URL=https://indexer-storage-turbo.0g.ai
ZG_MAINNET_PRIVATE_KEY=<mainnet_signer_private_key>
ZG_MAINNET_PROOF_REGISTRY_ADDRESS=0x8e63e117E71A80Cfc10fDF375F079e2e29cd7D7D
YIELD_STRATEGY_INFT_MAINNET_ADDRESS=0xb264D861264B0e4f8fb98A61B7694BA8a3B6BBe3
YIELD_STRATEGY_ATTESTATION_ORACLE_MAINNET_ADDRESS=0x216E7880D64D94335B583c539802d3e61958d4A2
GLOBAL_BLACKLIST_REGISTRY_MAINNET_ADDRESS=0xbc576EA5a68ED9d217299c107C801445e9A5a7BE
VALIDATION_REGISTRY_MAINNET_ADDRESS=0x62aa83b0A610BE298dF08004d764229B8f2aC219

Optional but recommended:

ZG_MAINNET_COMPUTE_PROVIDER_ADDRESS=<mainnet_compute_provider>
ZG_MAINNET_LEDGER_PRIVATE_KEY=<mainnet_compute_or_contract_signer>
KV_REST_API_URL=<optional_vercel_kv_url>
KV_REST_API_TOKEN=<optional_vercel_kv_token>
UPSTASH_REDIS_REST_URL=<optional_upstash_url>
UPSTASH_REDIS_REST_TOKEN=<optional_upstash_token>
ALIBABA_API_KEY=<dashscope_api_key>
ALIBABA_BASE_URL=https://dashscope-intl.aliyuncs.com/compatible-mode/v1
ALIBABA_MODEL=qwen3.6-plus-2026-04-02
ALIBABA_EMBEDDING_MODEL=text-embedding-v4
ALIBABA_EMBEDDING_DIMENSION=512
STRATEGY_METADATA_ENCRYPTION_KEY=<64_hex_or_32_byte_base64_secret>

3. Run the app

npm run dev

Open http://localhost:3000, then review:

• /judge for the hackathon audit path
• /agent for optimization execution
• /agents for contract mode or proof-backed fallback mode

4. Verify locally

npm run lint
npm run build
npm run test:ui

5. Optional contract / broker scripts

npm run deploy:proof-registry:mainnet
npm run deploy:inft:mainnet
npm run deploy:attestation-oracle:mainnet
npm run configure:inft-oracle:mainnet
npm run setup:tee-broker:mainnet

Testnet Secondary Path

Testnet is still available, but it is now a secondary path by design, not the center of the submission.

It is used for:

• broad tester participation without forcing every tester to spend mainnet gas
• repeated abuse testing on the faucet and vault challenge
• iteration on provider, wallet, and anti-sybil edge cases
• comparison during judging when someone wants to inspect both networks

What stays centered on testnet:

• Vault challenge public attack surface
• Anti-sybil faucet public airdrop example

What should be judged as the main production spine:

• 1-click optimize
• Verification console
• Developer store
• Anti-sybil + ZK + Alibaba fingerprinting module

If you want to run locally against testnet instead:

ZG_NETWORK_KEY=testnet
ZG_TESTNET_RPC_URL=https://evmrpc-testnet.0g.ai
ZG_TESTNET_STORAGE_URL=https://indexer-storage-testnet-turbo.0g.ai
ZG_TESTNET_PRIVATE_KEY=<testnet_signer_private_key>
ZG_TESTNET_PROOF_REGISTRY_ADDRESS=<optional_testnet_registry>
ZG_TESTNET_COMPUTE_PROVIDER_ADDRESS=<optional_testnet_compute_provider>
ZG_TESTNET_LEDGER_PRIVATE_KEY=<optional_testnet_signer>
YIELD_STRATEGY_INFT_ADDRESS=<optional_testnet_inft_contract>

The UI and /judge can still switch between mainnet and testnet from the same deployment.

Mainnet Submission Status

This repository is no longer in “mainnet prep only” mode. The current live state is:

• mainnet ProofRegistry deployed
• mainnet YieldStrategyINFT deployed
• mainnet storage tx and registry anchor already recorded
• live app defaults to mainnet
• developer store is live on the mainnet product path
• public vault and anti-sybil faucet are live as testnet-facing challenge/example surfaces
• the verification console can still switch to testnet when needed

Mainnet-related commands remain available for future redeployments or contract updates:

npm run deploy:proof-registry:mainnet
npm run deploy:inft:mainnet
npm run transfer:fund:broker:mainnet
npm run acknowledge:provider:mainnet
npm run setup:tee-broker:mainnet

Repository Pointers

File	Why it matters
app/api/agent/optimize/route.ts	Active optimization entry point.
lib/server/og-compute.ts	0G Compute broker integration.
lib/server/zero-g-storage.ts	Shared 0G JSON upload helper with honest local fallback for development.
app/api/0g/store/route.ts	Proof upload and registry anchoring.
app/api/agent/memory/route.ts	Sovereign Memory sync and read API.
app/api/auditor/blacklist/route.ts	Hallucination Blacklist write/read API.
app/api/stress-test/run/route.ts	Multiverse Stress Test runner and report API.
app/api/zk/verify/route.ts	Zero-Knowledge Proof Layer envelope API.
app/api/governance/evaluate/route.ts	Programmable AI Governance evaluator.
app/api/zk/compliance/route.ts	Deterministic policy seal builder.
app/api/agents/handshake/route.ts	Cross-Agent Neural Handshake transcript API.
app/faucet/page.tsx	Public anti-sybil faucet page for the airdrop-style example flow.
app/api/ya/faucet/claim	Faucet claim endpoint for the public anti-sybil airdrop example.
app/dev/marketplace/page.tsx	Developer store for YieldBoost AI Protocol, TITAN X, single-layer APIs, and selected partner SDK wrappers.
lib/server/runtime-store.ts	Proof persistence layer.
app/(workspace)/judge/page.tsx	Main audit review surface.
app/(workspace)/judge/roadmap/page.tsx	Audit-adjacent roadmap and value-capture surface.
components/judge/JudgeModeBootstrap.tsx	Wallet-free review bootstrap behavior.
contracts/ProofRegistry.sol	On-chain proof registry.
contracts/YieldStrategyINFT.sol	Strategy Agent NFT contract.
contracts/GlobalBlacklistRegistry.sol	Append-only CID registry for rejected hallucination artifacts.
contracts/ValidationRegistry.sol	On-chain anchor design for stress-test report cards.

Live Access Layer and Proof-of-Optimization

The public developer access layer is live, and it should be read with network honesty:

Surface	Live path	Purpose
Anti-sybil faucet	yieldboostai.xyz/faucet	Testnet airdrop-style example for public claims, anti-sybil checks, and Alibaba fingerprinting.
Developer portal	dev.yieldboostai.xyz	Hosts docs, store, playgrounds, and API integration surfaces.
Protocol store	dev.yieldboostai.xyz/marketplace	Mainnet-first security store for YieldBoost AI Protocol, TITAN X, single layers, anti-sybil modules, and selected partner SDK wrappers.
Public vault	yieldboostai.xyz/vault	Testnet public challenge surface for the YieldBoost protection model.

Current shipped base:

• Zero-Knowledge Proof Layer records the reasoning envelope as a reviewable 0G artifact.
• Programmable AI Governance turns strategy policy into deterministic status, risk, and kill-switch output.
• Cross-Agent Neural Handshake records the optimizer-to-auditor coordination transcript for external inspection.
• Anti-sybil faucet demonstrates the public airdrop-style abuse-resistance path, while store tiers sell the mainnet security stack as APIs and SDKs.

Access Utility Layer

• Reward wallets that submit optimization runs that are successfully stored and externally verifiable.
• Use proof-backed activity and API subscriptions, not vanity clicks, as the basis for ecosystem participation.
• Align developer access with storage-backed execution history, strategy quality, store access, and long-term protocol usage.
• Use the faucet as a public anti-sybil example first, then move serious users into paid 0G store tiers.

Proof-of-Optimization Mining

• Extend the live proof flow into a mining model where emission is tied to successful optimization proofs, not raw prompt volume.
• Weight rewards by signals such as proof anchoring success, portfolio size bands, APY improvement bands, and repeat verifiability.
• Treat ProofRegistry-backed executions as the highest-quality mining events.

Network Evolution

• Keep mainnet as the default public review path while preserving testnet as a secondary environment for experimentation and comparison.
• Add stronger proof economics around recurring optimization behavior and strategy sharing.
• Extend the current proof ledger into a richer reputation layer for agents, optimizers, and strategy curators.

Closing Position

YieldBoost AI is strongest when presented as a mainnet-live verifiable optimization product built around 0G infrastructure and judge-friendly audit UX.

The implementation already proves the essential idea:

• Compute can be routed through 0G
• proofs can be stored through 0G mainnet
• proofs can be anchored on-chain through ProofRegistry
• judges can review the latest result without wallet friction

That is a much more compelling hackathon story than a generic AI dashboard, because the output is not only generated, but also reviewable.

License

This project is released under the GNU Affero General Public License v3.0 only.

Contributing

Contributions are welcome through issues and pull requests. Please read CONTRIBUTING.md before proposing changes, especially for contract, proof, or 0G integration work.