# Table of Contents - [Hubic AI | Hubic.ai](#hubic-ai-hubic-ai) - [Proof-of-Inference (PoI) | Hubic.ai](#proof-of-inference-poi-hubic-ai) - [Introduction | Hubic.ai](#introduction-hubic-ai) - [Proof-of-Weights (PoWg) | Hubic.ai](#proof-of-weights-powg-hubic-ai) - [Main Actors and Their Roles | Hubic.ai](#main-actors-and-their-roles-hubic-ai) - [RWA Integration | Hubic.ai](#rwa-integration-hubic-ai) - [Hubic AI Hub – Model Registry | Hubic.ai](#hubic-ai-hub-model-registry-hubic-ai) - [Use Case Examples | Hubic.ai](#use-case-examples-hubic-ai) - [Architecture Overview | Hubic.ai](#architecture-overview-hubic-ai) - [Registry & System Architecture | Hubic.ai](#registry-system-architecture-hubic-ai) - [Sovereign AI Agents (On-chain AI Logic Executors) | Hubic.ai](#sovereign-ai-agents-on-chain-ai-logic-executors-hubic-ai) - [Liquid Strategy Engine (LSE) | Hubic.ai](#liquid-strategy-engine-lse-hubic-ai) - [Why Hubic? | Hubic.ai](#why-hubic-hubic-ai) - [Visual System Map | Hubic.ai](#visual-system-map-hubic-ai) - [Economic Model | Hubic.ai](#economic-model-hubic-ai) - [HUB Token Utility | Hubic.ai](#hub-token-utility-hubic-ai) - [Economic Actors & Reward Mechanics | Hubic.ai](#economic-actors-reward-mechanics-hubic-ai) - [Token Flow Diagram | Hubic.ai](#token-flow-diagram-hubic-ai) - [Optional Enterprise Layer | Hubic.ai](#optional-enterprise-layer-hubic-ai) - [Long-Term Sustainability | Hubic.ai](#long-term-sustainability-hubic-ai) - [Security & Reputation Systems | Hubic.ai](#security-reputation-systems-hubic-ai) - [Program Flow Overview | Hubic.ai](#program-flow-overview-hubic-ai) - [Summary Table | Hubic.ai](#summary-table-hubic-ai) - [Future Expansion Points | Hubic.ai](#future-expansion-points-hubic-ai) - [Model Registration (One-Time) | Hubic.ai](#model-registration-one-time-hubic-ai) - [Final Notes | Hubic.ai](#final-notes-hubic-ai) - [Hubic Intelligence Hub (Expanded) | Hubic.ai](#hubic-intelligence-hub-expanded-hubic-ai) - [Verification Phase | Hubic.ai](#verification-phase-hubic-ai) - [Inference Request (User Job) | Hubic.ai](#inference-request-user-job-hubic-ai) - [Proof-of-Weights (PoW2) | Hubic.ai](#proof-of-weights-pow2-hubic-ai) - [Execution Phase (Off-Chain) | Hubic.ai](#execution-phase-off-chain-hubic-ai) - [Governance System | Hubic.ai](#governance-system-hubic-ai) - [Optional Extensions | Hubic.ai](#optional-extensions-hubic-ai) - [Rewards & Settlement | Hubic.ai](#rewards-settlement-hubic-ai) - [Key Takeaways | Hubic.ai](#key-takeaways-hubic-ai) - [Real-World Use Case Example | Hubic.ai](#real-world-use-case-example-hubic-ai) - [Introduction | Hubic.ai](#introduction-hubic-ai) - [Problem Statement | Hubic.ai](#problem-statement-hubic-ai) - [System Actors | Hubic.ai](#system-actors-hubic-ai) - [End-to-End Flow: DAO Delegation Automation | Hubic.ai](#end-to-end-flow-dao-delegation-automation-hubic-ai) - [Benefits to DAO Operations | Hubic.ai](#benefits-to-dao-operations-hubic-ai) - [Extensions & Advanced Use | Hubic.ai](#extensions-advanced-use-hubic-ai) - [Roadmap | Hubic.ai](#roadmap-hubic-ai) - [Tokenomics | Hubic.ai](#tokenomics-hubic-ai) - [Introduction | Hubic.ai](#introduction-hubic-ai) - [Tokenomics | Hubic.ai](#tokenomics-hubic-ai) --- # Hubic AI | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FmZh7Fl0WoZC5LbOhEHOq%252FCover1%2520copy.png%3Falt%3Dmedia%26token%3Df67986fb-5790-4bab-a391-36f0976ae71e&width=768&dpr=4&quality=100&sign=48321ec8&sv=2) **Hubic AI is an Ethereum-native zkML protocol for verifiable inference, agent automation and RWA monetization.** It transforms AI models and autonomous logic into cryptographically proven, income-generating digital assets, seamlessly integrated into DAOs, DeFi protocols and enterprise workflows. * * * > ### > > [](https://docs.hubic.ai/#what-is-hubic) > > What is Hubic? Hubic enables: [](https://docs.hubic.ai/#tab-hubic-enables) * **Off-chain AI execution with on-chain zk-verification**, using Halo2, Groth16 or Plonk circuits. * **Modular smart contracts** for inference requests, proof validation, royalty settlement and zk-agent execution. * **AI-as-a-Service agents** that act autonomously on-chain (staking, governance, credit scoring, risk management). * **Tokenized models (RWAs)** with streamable revenue for holders, DAO-curated access and secondary market composability. * * * > ### > > [](https://docs.hubic.ai/#key-features) > > Key Features: Hubic Features: [](https://docs.hubic.ai/#tab-hubic-features) * **zk-Proven Inference:** AI predictions are cryptographically verifiable before they trigger any smart contract action. * **Composable Execution Flow:** Fully modular pipeline: `User → Executor → Verifier → zkRegistry → Settlement`. * **Slashing-secured trust:** Every action is incentivized, monitored and reputation-scored. * **RWA-native Architecture:** Model usage = income. Models are tokenized and can be owned, traded and governed. * **Agent Framework:** DAO bots, strategy agents and governance modules execute zk-backed automation in real time. * * * > ### > > [](https://docs.hubic.ai/#built-for) > > Built For: Hubic is built for: [](https://docs.hubic.ai/#tab-hubic-is-built-for) * **DAOs** – that want to replace manual operations with cryptographically proven agents. * **DeFi Protocols** – that need audit-grade credit scoring, market forecasting or liquidation agents. * **RWA Protocols** – that want to tokenize model performance, proof-based revenue streams or on-chain IP licensing. * **AI Developers** – that want to deploy monetizable models without central APIs or data custody risks. * * * > **Hubic is not just an AI protocol — it’s a cryptographic monetization engine for intelligent agents and autonomous infrastructure.** [NextIntroduction](https://docs.hubic.ai/embark-upon/quickstart) Last updated 1 month ago --- # Proof-of-Inference (PoI) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FUerHUnVECzwCvaEdHBwP%252F2.png%3Falt%3Dmedia%26token%3D3c0499f3-fd81-4fd3-9567-e585668b0103&width=768&dpr=4&quality=100&sign=36768995&sv=2) **Proof-of-Inference (PoI)** is Hubic’s core mechanism for ensuring the authenticity of every AI-generated output. Each inference must be accompanied by a zero-knowledge proof (zk-proof), generated off-chain and verified on-chain through Ethereum smart contracts. **✅ Guarantees:** * The model used is identified by a unique cryptographic hash. * Inputs are cryptographically committed and remain unchanged. * Outputs are deterministically derived from a registered zk-compatible model. * All outputs are verified on-chain before they can trigger any downstream logic. **🔁 Inference Flow:** Copy User Input → zk-Inference Node → zk-Proof + Output → Ethereum Verifier Contract → On-Chain Result **🧠 Why It Matters:** * Enables trustless, cryptographically guaranteed AI predictions. * Allows DeFi, DAOs and RWA contracts to depend on provable AI logic. * Preserves user privacy by never exposing raw inputs or outputs on-chain. * Creates a transparent audit trail for all inference activity. **🌍 RWA Integration:** PoI is critical to RWA tokenization — every zk-verified inference can serve as an on-chain proof of usage. These verifiable interactions underpin smart contracts that distribute revenue to RWA token holders, making AI outputs tangible, auditable and financially productive assets. [PreviousIntroduction](https://docs.hubic.ai/embark-upon/quickstart) [NextProof-of-Weights (PoWg)](https://docs.hubic.ai/embark-upon/quickstart/proof-of-weights-powg) Last updated 1 month ago --- # Introduction | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) **Hubic is an Ethereum-native protocol enabling cryptographically verifiable AI computation within a decentralized, trust-minimized execution framework.** It operates as an off-chain inference layer for zk-compatible AI models, producing outputs that are verifiable on-chain through Ethereum smart contracts. Unlike traditional AI services that rely on opaque APIs or centralized infrastructure, Hubic ensures: * `All AI predictions are accompanied by zero-knowledge proofs.` * `Verifiability of models and outputs via on-chain logic.` * `Full composability with on-chain agents, DAOs and financial primitives.` By embedding zero-knowledge proofs into AI inference workflows, Hubic unlocks transparent, auditable and scalable AI automation — including for Real World Asset (RWA) strategies where tokenized AI models produce provable, revenue-generating outputs. **Key Benefits:** * `**AI as Verifiable Infrastructure - Each output is tied to a zk-proof.**` * `**Ethereum-Native Agents - Integration with DAOs, DeFi and governance logic.**` * `**RWA Integration - Tokenized models and agents as income-bearing on-chain assets.**` Hubic is designed to serve as a foundational layer for trustless AI coordination — from agent-based finance to automated capital deployment — with Ethereum's battle-tested security and composability at its core. [PreviousHubic AI](https://docs.hubic.ai/) [NextProof-of-Inference (PoI)](https://docs.hubic.ai/embark-upon/quickstart/proof-of-inference-poi) Last updated 1 month ago --- # Proof-of-Weights (PoWg) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) **Proof-of-Weights (PoWg)** is a decentralized scoring framework used to evaluate and rank inference nodes in the Hubic network. Validators compute performance metrics for AI agents or inference nodes and must prove — via zero-knowledge proofs — that scoring was executed correctly. This zk-verified scoring ensures a reliable reputation system, which is essential for both network health and RWA-linked models that generate income based on performance. **🔧 How It Works:** 1. **Validator retrieves performance data** for a model or inference node. 2. **Scoring function is executed locally**, encapsulated in a zk-circuit. 3. **A zk-proof of execution is generated** and submitted on-chain. 4. **Scores and proofs are recorded and validated** via Ethereum smart contracts. **🔐 Security Guarantees:** * Prevents score manipulation or duplication across validators. * Validates that scoring was computed honestly using on-chain verifiable circuits. * Publishes score hashes and proofs to Ethereum for auditability and downstream automation. **🔁 Flow:** Copy Performance Metrics → Local Evaluation (zk-circuit) → zk-Proof + Scores → Ethereum Verifier → On-Chain Reputation Update **📊 Use Cases:** * **Node Reputation:** Reliable scoring ensures high-performing nodes are prioritized for critical inference tasks. * **Model Quality Tracking:** Models with better usage metrics and inference success rates can receive more traffic and fees. * **RWA Revenue Optimization:** RWA-linked models or agents can be scored transparently, with zk-proven logic determining payouts to token holders based on usage and performance quality. **🌍 RWA Relevance:** In the RWA context, PoWg is the accountability engine. It provides cryptographic proof that a model or AI agent is performing as expected — forming the basis for royalty distribution, dynamic pricing or trust-weighted access. High-score agents can command premium rates, attract capital flows and participate in enterprise or institutional deployments. [PreviousProof-of-Inference (PoI)](https://docs.hubic.ai/embark-upon/quickstart/proof-of-inference-poi) [NextWhy Hubic?](https://docs.hubic.ai/embark-upon/quickstart/why-hubic) Last updated 1 month ago --- # Main Actors and Their Roles | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) Hubic is built around a decentralized architecture of actors who interact through cryptographically verifiable logic on Ethereum. Each actor plays a distinct role in ensuring secure, scalable and economically aligned AI execution — especially when models are tokenized as Real World Assets (RWAs). **🧠 Inference Nodes (Executors)** These nodes perform off-chain AI inference jobs using zk-compatible models. They are responsible for: * Running the zk-circuit of a registered model. * Generating zero-knowledge proofs for each inference. * Submitting results + proofs for on-chain verification. **RWA Link:** Executors power the usage metrics that trigger royalty distributions to RWA token holders. More executions = more revenue = higher yield. **🧾 Validators** Validators manage task coordination and proof verification logic: * Dispatch inference jobs to available executors. * Verify zk-proofs and enforce model authenticity. * Submit validated results to Ethereum smart contracts. **RWA Link:** Validators act as guardians of verifiability — their role ensures that only genuine, audited activity is used in RWA-related revenue contracts. **📦 Ethereum Smart Contracts** These are the on-chain programs that anchor Hubic’s trust layer: * Manage model registration, proof validation, scoring logic. * Record logs, usage stats, performance scores immutably. * Trigger payouts, slashing or governance actions. **RWA Link:** All smart contracts involved in inference, scoring and payout are RWA-compatible — enabling models or agents to be financialized as income-bearing digital assets. Each actor contributes to the decentralized intelligence fabric of Hubic, ensuring that AI outputs are not only trustworthy but also economically meaningful — particularly in the emerging category of **AI-backed RWAs**. [PreviousWhy Hubic?](https://docs.hubic.ai/embark-upon/quickstart/why-hubic) [NextArchitecture Overview](https://docs.hubic.ai/embark-upon/quickstart/architecture-overview) Last updated 1 month ago --- # RWA Integration | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) **Hubic natively supports the tokenization of AI models and agents as Real World Assets (RWAs)** — enabling the protocol to transform verifiable inference into measurable, on-chain income streams. Models are no longer just code — they become **tokenized digital assets** that generate yield, accrue value and operate under cryptographic transparency. * * * **🧩 Core RWA Features:** Feature Description **Tokenized Ownership** Models can be fractionalized as ERC-20 or ERC-721 assets. **Usage-Based Yield** Every inference triggers on-chain royalty distribution to token holders. **zk-Verified Metrics** Revenue is based on cryptographically proven model activity. **Royalty Automation** Smart contracts distribute revenue per usage, without intermediaries. **DAO-Governed RWA Models** Model rights and fee structures can be governed by tokenized communities. * * * **🏦 Example RWA-Backed Assets:** * `HUBIC-RWAx`: AI model that performs 10,000 daily inferences; token holders earn 60% of collected fees. * `STRATEGY-NFT`: On-chain yield strategy managed by an AI agent; NFT holders receive 70% of yield generated. * `GOV-BOT-DAO`: DAO that owns a governance-focused AI agent; proposal participation rights are tokenized and tradable. * * * **🔁 Lifecycle of an RWA Model:** 1. **Model is registered** in the Hubic zkRegistry. 2. **RWA token** (ERC-20 or NFT) is issued, representing model ownership or yield rights. 3. Each inference: * Is verified by Ethereum smart contracts. * Triggers **royalty distribution** to token holders. * Updates on-chain **usage history and revenue metrics**. 4. Optional DAO governance modules allow: * Dynamic fee adjustment. * Voting on model upgrades or deprecation. * Shared ownership or revenue splits via staking contracts. * * * **🧠 Why This Matters:** > Hubic doesn't just verify AI — it monetizes it! Every interaction is a provable event. Every agent is a programmable RWA. Every inference is a financial micro-output, composable across DeFi, DAO and enterprise rails. With this model, **AI becomes a productive asset class on Ethereum**, where compute equals capital. [PreviousHubic AI Hub – Model Registry](https://docs.hubic.ai/embark-upon/quickstart/hubic-ai-hub-model-registry) [NextRegistry & System Architecture](https://docs.hubic.ai/embark-upon/quickstart-1) Last updated 1 month ago --- # Hubic AI Hub – Model Registry | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FMiloCV4pc3OQ2XzPbUQX%252F8.png%3Falt%3Dmedia%26token%3Df35b6163-f25f-4150-9d97-454d1e548d1b&width=768&dpr=4&quality=100&sign=a6c442a3&sv=2) The **Hubic AI Hub** is a permissionless registry of zk-compatible AI models. Deployed fully on-chain via Ethereum smart contracts, it serves as the trust anchor for all inference activity and monetization across the network. Each registered model is: * Identified by a unique zk-circuit hash. * Associated with metadata (version, type, zk format, usage fee). * Linked to a public verification key and on-chain logic. This registry enables transparent usage tracking, RWA tokenization and composability across Ethereum-based DAOs, DeFi protocols and dApps. * * * **📄 Sample Fields:** Field Description `Name` Human-readable label (e.g., “Yield Optimizer v1”) `Type` Model classification: Strategy, Agent, Scoring `zk Hash` SHA-256 hash of the compiled zk-circuit `Version` Compatible inference versioning (e.g., v1.1) `zk Format` Halo2, Risc0, zkWASM, etc. `Fee` Execution cost per inference `Verifier ID` Linked verification contract address `Royalty Split` On-chain percentage flow to model stakeholders `RWA Token ID` (optional) ERC-20/NFT representing model shares * * * **🧠 Example Models:** Name Type Verifiable? Version zk Hash Use Case Hubic-LSTM Strategy Engine ✅ v1.3 `0xabc123` DeFi Restaking Hubic-KYC Identity Agent ✅ v0.9 `0xdef456` zk-KYC for RWA access control Hubic-RWAx Revenue Model ✅ v1.0 `0x0f0f0f` Tokenized AI inference engine Hubic-Gov DAO Coordinator ✅ v2.1 `0xghi789` Governance Proposal Generator * * * **🌍 RWA Integration:** Models registered in the Hubic AI Hub can: * Be fractionalized and represented as ERC-20/NFT tokens. * Distribute yield from verified usage to token holders. * Maintain public audit trails for inference history and royalty claims. * Enable DAO-managed model ownership, upgrades or retirement through governance. This registry is the **foundation for real-world assetization of AI compute**, transforming inference models into trackable, monetizable primitives on Ethereum. [PreviousUse Case Examples](https://docs.hubic.ai/embark-upon/quickstart/use-case-examples) [NextRWA Integration](https://docs.hubic.ai/embark-upon/quickstart/rwa-integration) Last updated 1 month ago --- # Use Case Examples | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252F2hJ6yvZpkRylJTovcHpe%252F9.png%3Falt%3Dmedia%26token%3Dadd5ea99-72ad-466f-a199-4b88e8e41da1&width=768&dpr=4&quality=100&sign=5fcf1190&sv=2) Hubic enables a wide range of applications across Ethereum-native ecosystems — from DeFi and DAO tooling to RWA monetization and agent-driven automation. Below are key verticals where zk-verified AI outputs can power new economic primitives. **Restaking** Verifiable validator rotation using zk-scored performance metrics. **DeFi** AI-based credit scoring for undercollateralized loans, verified on-chain. **Governance** Agents that propose or vote in DAOs based on cryptographically proven inference. **RWA** Tokenized AI models where each inference generates revenue for token holders. **Trading** AI agents executing market actions with zk-verified rationale, enabling auditable algorithmic strategies. **Data Onboarding** zk-KYC agents that verify identity without leaking private data — used for gated RWA token access. **Subscription AI** Pay-per-inference models where proof-verified outputs are monetized like APIs. **Enterprise Ops** AI agents automating internal decisions (e.g., logistics, insurance pricing) with zk-proven logic. * * * **🌍 RWA-Specific Use Cases:** * **Tokenize AI model performance:** Model owners can sell access to model yield as an ERC-20 or fractional NFT. * **Royalty-backed Agents:** Deployed agents can collect task fees, distribute income to stakeholders and report performance on-chain. * **Audit-friendly Yield Streams:** zk-verified logs serve as immutable proof of utility and revenue — essential for real-world adoption and compliance. * **Decentralized Compute Licensing:** Organizations can purchase verifiable compute access, with all usage and earnings transparently recorded via smart contracts. Hubic enables the **real-world financialization of AI**, by connecting trustless compute to Ethereum’s programmable money infrastructure. [PreviousArchitecture Overview](https://docs.hubic.ai/embark-upon/quickstart/architecture-overview) [NextHubic AI Hub – Model Registry](https://docs.hubic.ai/embark-upon/quickstart/hubic-ai-hub-model-registry) Last updated 1 month ago --- # Architecture Overview | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FaAL2rlXch7ny29TAR7Ks%252F7.png%3Falt%3Dmedia%26token%3D7b01a879-8673-4816-81ac-3af1dcf9cc43&width=768&dpr=4&quality=100&sign=dc7c0de8&sv=2) Hubic introduces a modular zkML execution stack on Ethereum — optimized for decentralized inference, verifiable outcomes and on-chain integration with DAOs, DeFi and Real World Asset (RWA) flows. **🔁 End-to-End Flow:** Copy User/Protocol → Validator → Inference Node → zk-Proof + Output → Verifier Contract (Ethereum) → On-Chain Log + Action **🧬 zk-Inference Lifecycle:** 1. **User or DAO defines the task** and selects a registered AI model. 2. **Validator dispatches** the job to a zk-compatible inference node. 3. **Inference node executes** the model off-chain and generates a zk-proof. 4. **Validator verifies proof** and logs the result via Ethereum smart contract. 5. **On-chain events** trigger further actions: payouts, governance, RWA royalty distribution, etc. * * * **⚙️ Compatibility:** * Supports multiple zk formats: Halo2, Risc0, zk-WASM, zkVM. * Ethereum-native verifier contracts and ERC interfaces. * Ready for L2 integrations: Optimism, Base, Arbitrum for low-cost inference pipelines. * * * **🌍 RWA Embedding:** Hubic’s architecture treats every verified inference as an **on-chain income event**. This makes it ideal for: * **Tokenizing AI model usage rights** as ERC-20/721/1155 assets. * **Distributing yield** based on zk-verified activity (inference frequency, model accuracy). * **Embedding RWA logic** directly into protocol-level contracts — no need for external oracles or trust assumptions. This makes Hubic more than just a zkML layer — it's a programmable revenue fabric for AI-powered RWAs, where every output is a cryptographically secured microtransaction. [PreviousMain Actors and Their Roles](https://docs.hubic.ai/embark-upon/quickstart/main-actors-and-their-roles) [NextUse Case Examples](https://docs.hubic.ai/embark-upon/quickstart/use-case-examples) Last updated 1 month ago --- # Registry & System Architecture | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FUerHUnVECzwCvaEdHBwP%252F2.png%3Falt%3Dmedia%26token%3D3c0499f3-fd81-4fd3-9567-e585668b0103&width=768&dpr=4&quality=100&sign=36768995&sv=2) **Hubic’s protocol architecture is centered on verifiable AI execution**, designed to run seamlessly on Ethereum's smart contract layer and its modular scaling ecosystem (L2s, sidechains and storage layers). At its core, the system links zk-model registries, proof verifiers, AI agents and payment logic into a **trust-minimized, fully auditable flow** — enabling the tokenization of AI as productive assets (RWAs). * * * **🧱 Core Components:** Component Description **zkRegistry** On-chain registry of zk-compatible models with usage metadata. **Agent Accounts** Smart-contract-controlled agents that execute logic based on zk-inference. **Proof Submission Layer** Off-chain submitters of zk-proofs tied to AI tasks. **Ethereum Verifier Contracts** Validate proofs, track outputs, trigger economic logic. * * * **⚙️ Design Goals:** * **Ethereum-native**: Built for Solidity + EVM, deployable on L1 and L2. * **RWA-enabled**: Every AI inference can become a yield event tied to tokenized assets. * **Composable**: Easily integrates with DeFi protocols, DAO tooling and RWA dashboards. * **Transparent**: Full auditability of execution, proof submission and payout history. * * * **🔁 System Flow Summary:** Copy User/DAO → zkRegistry → Inference Node → zk-Proof → Ethereum Verifier Contract → Logs + Rewards Each module is designed to enforce **zero-trust AI execution**, ensuring that any downstream logic (governance, trading, licensing, staking) is backed by verified computation. [PreviousRWA Integration](https://docs.hubic.ai/embark-upon/quickstart/rwa-integration) [NextSovereign AI Agents (On-chain AI Logic Executors)](https://docs.hubic.ai/embark-upon/quickstart-1/sovereign-ai-agents-on-chain-ai-logic-executors) Last updated 1 month ago --- # Sovereign AI Agents (On-chain AI Logic Executors) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) **Sovereign AI Agents** are autonomous, smart contract–controlled actors deployed directly on Ethereum. They consume zk-verified model outputs and execute deterministic logic across governance, finance and data pipelines — without human intervention. These agents are not just executors — they are **tokenizable logic engines** that generate yield, enforce protocol policy or act as RWA-linked service nodes. * * * **🧠 Capabilities:** Function Description **zk-Driven Actions** Agents trigger smart contract logic based on zk-verified inference results. **Cross-Contract Coordination** Interact with multiple dApps across DeFi, DAO or RWA platforms. **Reactive Execution** Respond to on-chain state or off-chain signals. (e.g., price feeds, events) **Self-Governance** Each agent has a stake-based or DAO-governed controller. * * * **🧱 Struct (Simplified):** Copy pub struct SovereignAgent { id: Address, model_hash: bytes32, stake_contract: Address, controller: Address, agent_type: uint8, created_at: uint64, metadata_uri: string, state_hash: bytes32, last_executed: uint64 } * * * **🧩 Agent Types:** Type Function Example `StrategyExecutor` Deploys capital based on zk-validated AI outputs. (DeFi, restaking) `GovernanceBot` Submits or votes on proposals with zk-justified decisions. `DataScout` Feeds zk-signed external data for model use or DAO consumption. * * * **🌍 RWA Integration:** * **Tokenized Agents:** Agents can be fractionalized as NFTs or ERC-20s, with yield rights tied to performance. * **Royalty Distribution:** Each successful task execution triggers a share of revenue to stakeholders. * **Auditable Automation:** All actions are zk-verified and stored on-chain — enabling AI-powered assets with legally auditable trails. > **Hubic Agents = Autonomous RWA Infrastructure** Deployable. Composable. Monetizable. These agents make it possible to create AI-driven income machines — whether executing trades, approving DAO actions or orchestrating enterprise logic — with every step cryptographically proven and economically rewarded. [PreviousRegistry & System Architecture](https://docs.hubic.ai/embark-upon/quickstart-1) [NextLiquid Strategy Engine (LSE)](https://docs.hubic.ai/embark-upon/quickstart-1/liquid-strategy-engine-lse) Last updated 1 month ago --- # Liquid Strategy Engine (LSE) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FRNdiKSO24kjnsAla1iyD%252F6.png%3Falt%3Dmedia%26token%3D9e2f3a23-d732-4ae3-92d1-05de52a84ecb&width=768&dpr=4&quality=100&sign=a1300f29&sv=2) The **Liquid Strategy Engine (LSE)** is Hubic’s on-chain capital automation module. It enables zk-verified AI agents to execute financial strategies directly on Ethereum — including staking, trading, lending and rebalancing — all driven by inference outputs validated with zero-knowledge proofs. Every action is verifiable. Every execution is programmable. Every strategy is a financial primitive. * * * **🔁 Execution Flow:** Copy zk-Inference → Ethereum Verifier Contract → StrategyExecution Struct → On-Chain DeFi Calls * * * **📦 StrategyExecution Struct:** Copy struct StrategyExecution { bytes32 strategy_id; address agent_address; DeFiAction[] actions; uint64 timestamp; bytes32 inference_hash; bytes32 execution_digest; } This structure cryptographically commits each strategy to the zk-proven inference that triggered it. The `execution_digest` represents a hashed simulation outcome verified off-chain. * * * **⚙️ Supported Actions (Abstracted Enum):** Copy enum DeFiAction { Swap(tokenIn, tokenOut, amount), Stake(protocol, token, amount), Borrow(protocol, collateral), Unstake(protocol, token), Custom(callData) } This action set gives agents universal access to DeFi protocols, AMMs, lending markets or custom on-chain instructions. * * * **🌍 RWA Implications:** `⦿ Model-Driven Capital: AI agents can manage tokenized capital pools, issuing yield-bearing RWA shares.` `⦿ Proof-Based Perfomance: Every portfolio adjustment is backed by zk-proven strategy logic.` `⦿ On-Chain Revenue Accounting: Profits and losses are automatically tied to model owners or token holders.` > AI becomes a **composable money manager** — and every transaction is enforceable by code, auditable by proof and monetizable as a Real World Asset. * * * **🧠 Example:** Copy +---------------------------+ | zk-Restaking Model | | (Validator Scoring AI) | +------------+--------------+ | v +----------------------------+ | LSE Agent (Strategy) | | Rebalances ETH allocations | +------------+---------------+ | v +----------------------------+ | zk-Proof Generation | | (Executor Node off-chain) | +------------+---------------+ | v +----------------------------+ | Ethereum Verifier SC | | Validates model & output | +------------+---------------+ | v +----------------------------+ | Execution Digest Log | | (Proof of strategy run) | +------------+---------------+ | v +----------------------------+ | Fee Collection Module | | (e.g. 100 HUB per job) | +------------+---------------+ | v +------------------------------+ | RWA Token Contract (ERC-20) | | Distributes yield to holders | +------------------------------+ [PreviousSovereign AI Agents (On-chain AI Logic Executors)](https://docs.hubic.ai/embark-upon/quickstart-1/sovereign-ai-agents-on-chain-ai-logic-executors) [NextProof-of-Weights (PoW2)](https://docs.hubic.ai/embark-upon/quickstart-1/proof-of-weights-pow2) Last updated 1 month ago --- # Why Hubic? | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FRNdiKSO24kjnsAla1iyD%252F6.png%3Falt%3Dmedia%26token%3D9e2f3a23-d732-4ae3-92d1-05de52a84ecb&width=768&dpr=4&quality=100&sign=a1300f29&sv=2) In traditional AI infrastructure, inference outputs are opaque, unverifiable and reliant on centralized APIs. **Hubic changes that.** It transforms AI from a black-box process into a **verifiable, auditable and monetizable computation layer** — fully embedded in Ethereum’s on-chain logic. **🚫 Traditional AI APIs:** * Opaque logic with no proof of correctness. * No audit trail for model decisions. * Centralized and permissioned infrastructure. * Cannot support tokenized incentives or on-chain composability. **✅ Hubic on Ethereum:** On-chain verifiability ❌ ✅ via zk-proofs Model transparency ❌ ✅ (hash-verified) Execution decentralization ❌ ✅ (open zk-inference) Smart logic integration ❌ ✅ (composable agents) Incentive mechanisms ❌ ✅ (token + RWA logic) **🌍 What Makes Hubic Different:** * 🧾 **Proof-Backed Outputs:** Every model output is accompanied by a zk-proof and validated by Ethereum contracts. * 🧠 **Composable zk-Agents:** Outputs can drive DAO votes, DeFi actions or capital deployment through trustless automation. * 🌐 **RWA Integration:** Tokenized models become income-generating assets — with usage-based payouts governed by smart contracts. * 📈 **Decentralized Scoring:** AI nodes are continuously rated via zk-verified metrics, powering a transparent reputation economy. Hubic enables verifiable intelligence to serve as collateral, input for governance or yield-bearing infrastructure in Ethereum-native ecosystems — especially in **tokenized RWA strategies** where trust and auditability are non-negotiable. [PreviousProof-of-Weights (PoWg)](https://docs.hubic.ai/embark-upon/quickstart/proof-of-weights-powg) [NextMain Actors and Their Roles](https://docs.hubic.ai/embark-upon/quickstart/main-actors-and-their-roles) Last updated 1 month ago --- # Visual System Map | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) This high-level diagram illustrates the architecture and information flow across the Hubic protocol, from inference input to on-chain validation and RWA-linked monetization. * * * Copy ┌────────────────────────┐ │ External Users │ │ (DAOs, dApps, DeFi) │ └────────────┬───────────┘ │ (task + input + payment) ▼ ┌────────────────────────────┐ │ Validators │ │ • Route inference jobs │ │ • Assign registered models │ └────────────┬───────────────┘ ▼ ┌────────────────────────┐ │ Inference Nodes │ │ • Run zk-model locally │ │ • Generate zk-Proof │ └────────────┬───────────┘ ▼ ┌────────────────────────────┐ │ Ethereum Verifier Contract│ │ • Validate proof + hashes │ │ • Log inference + output │ └────────────┬───────────────┘ ▼ ┌────────────────────────┐ │ zkRegistry + LSE │ │ • Link result to model │ │ • Trigger agent logic │ └────────────┬───────────┘ ▼ ┌────────────────────────┐ │ AI Agents & RWA │ │ • Execute DeFi logic │ │ • Distribute rewards │ │ • Update RWA metrics │ └────────────────────────┘ * * * **🔍 Key Elements:** `⦿ zkRegistry: Ensures the model used is valid, registered and RWA-bound if applicable.` `⦿ Verifier Contract (Ethereum): Guarantees proof correctness — mandatory before any payout or on-chain effect.` `⦿ LSE & Agents: React to verified outputs and execute capital strategies.` `⦿ RWA Smart Contracts: Receive execution reports and distribute revenue to token holders based on zk-backed performance.` * * * **🌍 RWA View:** This system ensures that **every inference, score or execution becomes a traceable, monetizable and enforceable event** — enabling models and agents to be treated as financial assets with: `⦿ Deterministic value accrual.` `⦿ Transparent usage metrics.` `⦿ DAO-governed fee structures.` `⦿ Legally auditable execution logs.` Hubic is the execution engine. zkML is the logic. Ethereum is the court. RWA is the outcome. [PreviousHubic Intelligence Hub (Expanded)](https://docs.hubic.ai/embark-upon/quickstart-1/hubic-intelligence-hub-expanded) [NextEconomic Model](https://docs.hubic.ai/embark-upon/quickstart-2) Last updated 1 month ago --- # Economic Model | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FaAL2rlXch7ny29TAR7Ks%252F7.png%3Falt%3Dmedia%26token%3D7b01a879-8673-4816-81ac-3af1dcf9cc43&width=768&dpr=4&quality=100&sign=dc7c0de8&sv=2) Hubic implements a **tokenized economic layer** that governs all verifiable AI activity — from model registration and proof generation to execution rewards and RWA-based revenue distribution. Powered by the **HUB token**, this system aligns economic incentives with trust, performance, and decentralized ownership. Everything is on-chain, transparent, and enforced by zk-proofs. * * * **🧩 HUB Token Utility:** Use Case Description **Inference Payments** Users pay for zk-verified inference jobs using HUB or stablecoins **Staking for Access** Executors and validators stake HUB to participate in job routing **Reward Distribution** All successful participants earn HUB based on performance **Governance Rights** HUB holders vote on models, fees, upgrades, and agent behavior **Premium Access / Subscriptions** Lock HUB for bulk inference, priority access, or enterprise SLAs * * * **🎯 Dual Role: Fee + Reputation** The HUB token acts both as: * **Gas layer** for verifiable computation (execution, proof, scoring) * **Reputation score** — long-term stakers gain higher access priority, governance influence, and better task routing * * * **🌍 RWA Integration:** * **RWA Collateralization:** HUB can be staked to back RWA-tokenized models or agents, securing yield streams or acting as underwriting. * **Royalty Distribution:** HUB is used to distribute or claim revenue generated by tokenized AI models. * **Proof-Based Earnings:** All payouts are triggered only upon zk-verified usage — ensuring HUB is spent/earned based on provable computation. > HUB isn’t just fuel — it’s the governance, credibility, and cashflow backbone of verifiable AI on Ethereum. * * * **💰 Example:** A DAO uses a governance bot agent to automate treasury decisions. Each task costs 2 HUB. zk-proofs confirm execution. Revenue is distributed: * 60% to the agent’s model owner (RWA-tokenized) * 20% to the executor * 20% to the validator [PreviousVisual System Map](https://docs.hubic.ai/embark-upon/quickstart-1/visual-system-map) [NextHUB Token Utility](https://docs.hubic.ai/embark-upon/quickstart-2/hub-token-utility) Last updated 1 month ago --- # HUB Token Utility | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) The **HUB token** is the backbone of economic coordination in the Hubic ecosystem. It powers every layer of the protocol — from compute and validation, to governance and revenue flows. * * * **🔧 Primary Utility Domains:** Function Mechanism **Inference Payments** Users pay in HUB or stablecoins (e.g. USDC); HUB gives discounts & priority **Validator/Executor Staking** Required stake to participate in task routing and proof generation **Performance-Based Rewards** Earn HUB based on uptime, accuracy, proof efficiency **Governance Rights** Vote on model inclusion, fee changes, RWA token settings, protocol upgrades **Premium Tiers / Subscriptions** Lock HUB for access to enterprise-grade throughput or APIs * * * **🧠 RWA Context:** * **Tokenized Models & Agents:** Can issue ERC-20s representing future yield. HUB is used to claim these yields or stake against their performance. * **Collateral Layer:** DAOs or institutional users may stake HUB to access or insure high-value RWA agents. * **Programmable Revenue Distribution:** Smart contracts auto-route HUB to token holders tied to usage proofs. > HUB is the native unit of value, trust, and access in a world where compute = cashflow. * * * #### [](https://docs.hubic.ai/embark-upon/quickstart-2/hub-token-utility#reward-mechanics) 🔹 Reward Mechanics Hubic rewards three key roles: **Model Owners**, **Executors**, and **Validators**. Rewards are distributed per inference job, based on a zk-verified outcome. * * * **💸 Standard Distribution (Per Inference Fee):** Recipient Role Share Model Owner Supplies the zk-model **60%** Executor Runs inference + proof **20%** Verifier Node Validates proof **20%** * * * **🧮 Example:** A user submits a job and pays **100 HUB**. → 60 HUB → to model owner (or RWA token smart contract) → 20 HUB → to executor who performed zk-inference → 20 HUB → to verifier who validated the result on-chain * * * **📈 Incentive Enhancements:** * **Reputation Bonuses:** High-performing nodes earn HUB multipliers based on zk-verified score history. * **Slash Conditions:** Faulty proof submission = slashing of staked HUB. * **Dynamic Fee Modifiers:** Based on demand, reputation, and model performance metrics. * * * **🌍 RWA Integration:** * **Tokenized Model Ownership:** Revenue from the 60% model owner fee can be split among RWA token holders automatically. * **Governable Fee Allocation:** DAOs can propose and vote on changing model fees, reward splits, or adding dynamic fee logic. * **Proof-Based ROI Tracking:** RWA dashboards can track yield in real-time using verified inference logs. [PreviousEconomic Model](https://docs.hubic.ai/embark-upon/quickstart-2) [NextEconomic Actors & Reward Mechanics](https://docs.hubic.ai/embark-upon/quickstart-2/economic-actors-and-reward-mechanics) Last updated 1 month ago --- # Economic Actors & Reward Mechanics | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FMiloCV4pc3OQ2XzPbUQX%252F8.png%3Falt%3Dmedia%26token%3Df35b6163-f25f-4150-9d97-454d1e548d1b&width=768&dpr=4&quality=100&sign=a6c442a3&sv=2) Hubic’s decentralized economy is structured around **three primary roles**, each contributing to the zk-compute pipeline and earning HUB based on verified outputs: * * * **👤 1. Model Owners** **Role:** Register zk-compatible AI models to the on-chain registry. They define pricing and receive a share of all inference fees generated by their models. **💸 Revenue Model:** * Set a flat or dynamic price per inference call. * Earn a **default 60%** share of every valid task using their model. * Can tokenize model ownership as ERC-20/NFT to distribute income. **🌍 RWA Integration:** * **Tokenized ownership:** Revenue is streamed to token holders. * **DAO-managed models:** Governance over fee structure, model updates, and upgrade rights. * * * **⚙️ 2. Executors (zk-Inference Nodes)** **Role:** Run the model’s zk-circuit off-chain and generate a proof. **🧾 Participation Requirements:** * Stake HUB to enter execution pools. * Meet proof latency and compactness constraints. **💰 Compensation:** * Earn **20%** of inference fee per job. * Bonus tiers for proof efficiency, model diversity, and low error rates. **📈 Enhancements:** * Performance history boosts future routing priority. * zk-signed benchmarks can be published for discoverability. * * * **✅ 3. Verifiers (Validation Nodes / Contracts)** **Role:** Confirm the integrity of each proof and enforce correctness. **🔍 Responsibilities:** * Load model hash and verification key from the registry. * Match proof → input → model → output. * Trigger payment or slashing. **💰 Rewards:** * Receive **20%** of inference fee per successful verification. * Long-term bonuses based on uptime and audit performance. **⚠️ Slashing Conditions:** Misbehavior Penalty Applied Accepting invalid proof Slashing of staked HUB Collusion with executor Slash + blacklisting Missed validation SLA Loss of role + reward cut * * * **⚖️ Revenue Split Summary (Per Inference Job):** Actor Share (%) Paid In Notes Model Owner 60% HUB Can be auto-routed to RWA holders Executor Node 20% HUB zk-proof generation Verifier Node 20% HUB On-chain proof validation * * * > This system ensures that all compute work, validation, and model ownership is **financially accountable, proof-enforced, and natively composable** with RWA tokens and Ethereum protocols. [PreviousHUB Token Utility](https://docs.hubic.ai/embark-upon/quickstart-2/hub-token-utility) [NextToken Flow Diagram](https://docs.hubic.ai/embark-upon/quickstart-2/token-flow-diagram) Last updated 1 month ago --- # Token Flow Diagram | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252F2hJ6yvZpkRylJTovcHpe%252F9.png%3Falt%3Dmedia%26token%3Dadd5ea99-72ad-466f-a199-4b88e8e41da1&width=768&dpr=4&quality=100&sign=5fcf1190&sv=2) This section illustrates the economic pathway of the HUB token during a typical AI inference lifecycle. All payments, validations, and distributions are tightly coupled with zk-proof verification and on-chain enforcement. * * * **🧭 Flow Summary (Per 100 HUB Job):** Copy [User / dApp] │ Pays 100 HUB for zk-Inference ▼ ┌─────────────────────┐ │ Inference Engine │ │ + zkProof Gen │ └────────┬────────────┘ │ ▼ ┌─────────────────────┐ │ Verifier Contract │ │ + Proof Validation │ └────────┬────────────┘ │ ▼ ┌────────────────────────────────────────────┐ │ Settlement Contract (Ethereum) │ │ • Logs output + proof │ │ • Distributes payment based on outcome │ └────────┬───────────────────────────────────┘ ▼ ┌────────────┬────────────┬────────────┐ │ Model │ Executor │ Verifier │ │ Owner │ Node │ Node │ │ (or RWA) │ │ │ │ 60 HUB │ 20 HUB │ 20 HUB │ └────────────┴────────────┴────────────┘ * * * #### [](https://docs.hubic.ai/embark-upon/quickstart-2/token-flow-diagram#settlement-logic) 🔹 Settlement Logic All HUB token transfers are executed automatically by smart contracts once a zk-proof is validated on-chain. If the proof is invalid or incomplete, no payout occurs, and staked parties may be slashed. * * * **🔄 On-Chain Settlement Process:** 1. **Verifier submits proof + validation metadata** 2. **zkRegistry checks:** * Is the model registered? * Does the proof match the model hash? * Was the inference properly routed? 3. **Settlement contract triggers payouts:** * Funds are sent atomically from escrow. * Usage history is updated for scoring/royalty tracking. * Events emitted for dashboard / RWA sync. * * * **⚠️ Failsafe Mechanisms:** Case Outcome Invalid proof No payout, potential slashing Delayed executor Penalty applied or job reassigned Unregistered model Job rejected, refund issued to user * * * **🌍 RWA Considerations:** * **Royalty Streams:** Model owner payout can be redirected to RWA token contracts, distributing yield to token holders. * **Auditability:** Every inference and reward is linked to an event + zk-proof → usable in dashboards, reporting, and compliance. * **Trustless Execution:** Because every payment is proof-gated, RWA structures inherit the same integrity guarantees. > Hubic transforms payment logic from “reputation-based” to “proof-enforced” — ideal for powering tokenized, revenue-yielding AI assets on Ethereum. [PreviousEconomic Actors & Reward Mechanics](https://docs.hubic.ai/embark-upon/quickstart-2/economic-actors-and-reward-mechanics) [NextLong-Term Sustainability](https://docs.hubic.ai/embark-upon/quickstart-2/long-term-sustainability) Last updated 1 month ago --- # Optional Enterprise Layer | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) For organizations, DAOs, and institutions requiring predictable access to AI inference at scale, Hubic provides an **enterprise-grade execution tier**. This layer offers **performance guarantees**, **dedicated compute pipelines**, and **fine-grained monetization controls** — all governed by smart contracts on Ethereum. * * * **🧾 1. Subscription-Based Access** Enterprises can subscribe to predefined packages by locking HUB tokens, unlocking: * Discounted inference rates based on commitment volume. * Guaranteed throughput even during network congestion. * Priority execution for business-critical inference jobs. * * * **💳 2. Usage-Based Credit System** Instead of locking large amounts of HUB, organizations may use **pay-as-you-go credits**, priced dynamically based on model complexity and volume: Mechanism Benefit **HUB burn for access** Temporary priority queue position **Time-limited access credits** Optimize short bursts of compute or pilot deployments **Category-specific limits** Customize credit per model type (e.g. trading vs RWA) * * * **🔐 3. Whitelisted Nodes & Private Inference** For sensitive workloads, Hubic supports the deployment of **permissioned execution clusters**: Feature Description **Custom Executor-Validator Pairs** Assign private zk-agents to internal data only **Encrypted Inference Logs** Store private outputs using zk-commitments + IPFS **Private Registries** Run isolated zkRegistry clones for NDA-bound models > These tools enable RWA asset managers, insurance firms, trading funds, or regulated DAOs to run AI in a **confidential but verifiable setting** — with fully enforceable on-chain monetization. * * * **🌍 RWA Extensions:** * **Private RWA Agents:** Enterprises can tokenize exclusive access to a closed-source model (e.g. via ERC-721 gating). * **Governance-Limited Execution:** Only specific wallets or DAO members can trigger agent actions. * **Proof-Verified SLAs:** zk-validated logs serve as compliance-grade execution attestations. [PreviousLong-Term Sustainability](https://docs.hubic.ai/embark-upon/quickstart-2/long-term-sustainability) [NextSecurity & Reputation Systems](https://docs.hubic.ai/embark-upon/quickstart-2/security-and-reputation-systems) Last updated 1 month ago --- # Long-Term Sustainability | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FUerHUnVECzwCvaEdHBwP%252F2.png%3Falt%3Dmedia%26token%3D3c0499f3-fd81-4fd3-9567-e585668b0103&width=768&dpr=4&quality=100&sign=36768995&sv=2) Hubic’s architecture is designed not just for performance — but for durability. To ensure long-term alignment between compute contributors, RWA stakeholders, and governance participants, the protocol implements **automated treasury allocations**, **incentive reserves**, and **dynamic pricing mechanisms**. * * * **💰 Treasury Allocation** A portion of every inference payment is redirected to the **Hubic Treasury** smart contract. **Default Allocation:** * **5% of every inference fee** (in HUB or stablecoins) * Collected and governed on-chain **Treasury Use Cases:** Category Description **Developer Grants** Funding for zk-model builders, RWA integration tools, AI agents **Security Bounties** Rewards for discovering vulnerabilities in verifier contracts **Liquidity Provision** Providing depth on DEXs (Uniswap, Balancer) for HUB pairs **DAO Incentives** Bootstrap capital for communities managing tokenized agents * * * **⚙️ Dynamic Pricing Engine (Planned)** Hubic integrates a pricing oracle + policy layer to adapt to market conditions and network demand: **Mechanisms:** Strategy Behavior **Gas-Aware Inference Pricing** Adjusts inference cost based on L1/L2 congestion **Model Demand Scaling** Heavily used models increase in cost over time **Introductory Discounts** New or low-usage models receive lower base rates **Subscription Tiers** Users can lock HUB for discounted bulk access or RWA model slots * * * **🌍 RWA Relevance:** * **Predictable Yield Flows:** Dynamic pricing smooths volatility in revenue forecasts for tokenized models. * **Treasury-Backed Stability:** A portion of protocol income can be routed to collateralize RWAs or maintain floor pricing. * **Governable Allocations:** RWA token holders can vote on how treasury funds impact model ecosystem or agent upgrades. > Sustainability is not a static parameter — it’s a programmable feedback loop between performance, pricing, and economic flow. [PreviousToken Flow Diagram](https://docs.hubic.ai/embark-upon/quickstart-2/token-flow-diagram) [NextOptional Enterprise Layer](https://docs.hubic.ai/embark-upon/quickstart-2/optional-enterprise-layer) Last updated 1 month ago --- # Security & Reputation Systems | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) To maintain integrity across decentralized AI execution and RWA revenue automation, Hubic implements a **layered security framework**. This combines real-time zk-proof enforcement, slashing conditions, and on-chain reputation metrics — forming a self-regulating trust system. * * * **🛡️ Risk Mitigation Matrix** Threat Mitigation (On-Chain Enforced) **Faulty Inference** zk-proof validation enforced by verifier contracts **Lazy Validators** Automatic slashing of HUB for missed validations **Executor Downtime** Dynamic reassignment using smart contract task requeue **Model Spoofing** zkRegistry prevents unverified or tampered model usage **Collusion Behavior** Multi-node challenge + dispute resolution protocol * * * **📊 Reputation Layer** Every compute actor — executor, validator, or agent — has an **on-chain reputation score**, based on cryptographically provable performance: Metric Tracked Via **Uptime** Number of tasks completed vs missed **Proof Accuracy** zk-proof pass/fail ratio **Latency & SLA Adherence** Execution timestamps + event logs **Dispute Outcomes** Challenge resolution win/loss history **RWA Yield Efficiency** Inference-to-revenue ratio (for monetized models) * * * **🧩 Integration with Protocol Logic** * **Staking Weighting:** High-reputation actors get higher task routing priority and slashing protection. * **Governance Influence:** DAO voting rights may be boosted for agents or validators with strong historical accuracy. * **Dynamic Reward Multipliers:** Protocol bonuses scale with verified contribution quality. * * * **🌍 RWA Impact:** * **Revenue Routing Based on Trust:** Only models/agents with clean reputation earn RWA-based income. * **Transparent Yield Quality:** RWA token holders can validate performance history before investing. * **Compliance Friendly:** All data is verifiable and timestamped, allowing integration with legal reporting or off-chain attestations. > Trust in Hubic is not reputation by hearsay — it’s mathematically proven, stake-weighted, and economically enforced. [PreviousOptional Enterprise Layer](https://docs.hubic.ai/embark-upon/quickstart-2/optional-enterprise-layer) [NextSummary Table](https://docs.hubic.ai/embark-upon/quickstart-2/summary-table) Last updated 1 month ago --- # Program Flow Overview | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FRNdiKSO24kjnsAla1iyD%252F6.png%3Falt%3Dmedia%26token%3D9e2f3a23-d732-4ae3-92d1-05de52a84ecb&width=768&dpr=4&quality=100&sign=a1300f29&sv=2) This section describes the **complete lifecycle of an AI inference** within the Hubic Protocol — from model registration to zk-proof execution, verification, and reward distribution — all coordinated by Ethereum smart contracts. This modular pipeline ensures: * Fully verifiable execution logic (via zk-proofs) * Transparent, slashing-secured task delegation * Native support for RWA tokenization and revenue distribution * * * **🧬 Core Flow Diagram:** Copy scssCopyEdit[Model Dev] → zkRegistry → [User Input] → Inference Request ↓ ↓ [Executor Node] — zk-Proof —> Verifier Contract (Ethereum) ↓ ↓ [Settlement Contract] → Rewards + Logs ↓ [RWA Smart Contracts] → Tokenized Yield Flow (optional) * * * **🔗 Components Covered:** 1. **Model Registration (One-Time):** Upload and register zk-compatible models. 2. **Inference Request (User Job):** Users trigger tasks using registered models. 3. **Execution Phase (Off-Chain):** Executor runs circuit and generates zk-proof. 4. **Verification Phase:** Proof is validated on-chain. 5. **Rewards & Settlement:** Payment distribution via Ethereum smart contracts. 6. **Optional Extensions:** Private inference, batch jobs, DAO gating. 7. **Key Takeaways:** Summary of verifiability, automation, and RWA alignment. [PreviousFinal Notes](https://docs.hubic.ai/embark-upon/quickstart-2/final-notes) [NextModel Registration (One-Time)](https://docs.hubic.ai/embark-upon/quickstart-3/model-registration-one-time) Last updated 1 month ago --- # Summary Table | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) This table summarizes how different participants interact with the Hubic protocol, what they earn, whether they require staking, and how slashing is applied. It's the foundation of the **zk-powered AI economy** on Ethereum. **Role** **Earns From** **Stakes HUB?** **Subject to Slashing** **Reward Type** **Model Owner** Inference usage (60%) No No Passive (or RWA-linked) **Executor** zk-proof execution (20%) + bonuses Yes Yes Performance-based **Verifier** Proof validation (20%) Yes Yes Accuracy-based + uptime incentives **RWA Token Holder** Royalty share from model/token usage Optional (if staked) No Yield-generating via smart contract > This structure enables **verifiable income streams**, tied to computational work and proof correctness — and is natively extensible to RWA use cases. * * * [PreviousSecurity & Reputation Systems](https://docs.hubic.ai/embark-upon/quickstart-2/security-and-reputation-systems) [NextFuture Expansion Points](https://docs.hubic.ai/embark-upon/quickstart-2/future-expansion-points) Last updated 1 month ago --- # Future Expansion Points | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FaAL2rlXch7ny29TAR7Ks%252F7.png%3Falt%3Dmedia%26token%3D7b01a879-8673-4816-81ac-3af1dcf9cc43&width=768&dpr=4&quality=100&sign=dc7c0de8&sv=2) To evolve into a fully composable zkML + RWA infrastructure layer for Ethereum, Hubic’s roadmap includes several protocol-level enhancements designed to increase network utility, governance resilience, and real-world integration. * * * **1\. 🔄 Multi-Token Payment Support** * Enable inference fees to be paid in stablecoins like **USDC**, **DAI**, or even wrapped ETH. * Smart contract router handles conversion and distribution. * Reduces friction for institutions and DAOs operating with non-native assets. * * * **2\. 🏅 zk-Reputation NFTs** * Non-transferable NFTs representing **provable service history**: * High-accuracy executors * Trusted validators * Consistently monetized models * Usable as on-chain credentials or role badges in governance or B2B access systems. * * * **3\. 🧠 Treasury-Governed Model Onboarding** * For sensitive, high-impact, or RWA-linked models, onboarding could require DAO or treasury curation. * Governance filters include: * Usage volume * Inference accuracy * Reputation metrics * Potential financial exposure (e.g. insurance pricing, trading) * * * **4\. ⚖️ zkML-Governed Voting Weights** * Voting weight influenced by verifiable contribution metrics: * Proof accuracy * Volume of inferences executed or validated * Yield impact of deployed strategies * Enables a shift from "token-only governance" to **performance-aware voting**. * * * **5\. 🌍 RWA-Specific Modules** * **Bonding Curves for RWA Tokens:** Dynamic pricing of access to high-performing models. * **RWA Vaults:** Smart contracts that collect and distribute revenue based on model usage. * **Tokenized Licensing:** Limited-time or usage-based access to proprietary AI via NFT issuance. * **Legal Oracles:** Integrate proof-backed execution logs with real-world audit/reporting frameworks. * * * > These expansion points aim to position Hubic as the **governance-ready, monetization-focused zkML backbone of Ethereum**, with long-term sustainability and real-world compatibility embedded at the core. [PreviousSummary Table](https://docs.hubic.ai/embark-upon/quickstart-2/summary-table) [NextFinal Notes](https://docs.hubic.ai/embark-upon/quickstart-2/final-notes) Last updated 1 month ago --- # Model Registration (One-Time) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) Before an AI model can be used within the Hubic network, it must be registered through a one-time process that cryptographically anchors its identity, verification logic, and metadata to Ethereum smart contracts. This ensures: * **Immutable model identity** * **Proof compatibility enforcement** * **Optional RWA token linkage** * * * **🧾 Registration Workflow:** 1. **Model developer** compiles the model into a zero-knowledge circuit. 2. A **unique hash** (e.g. SHA-256 of the zk-circuit) is generated. 3. Metadata is prepared (e.g. zk format, version, license terms). 4. Developer submits to the `zkRegistry` via `ModelSubmission` contract. * * * **📦 On-Chain Structure (Simplified):** Copy struct ModelSubmission { bytes32 model_hash; // Unique zk-circuit hash address verifier_contract; // Ethereum contract used for zk verification address owner; // Wallet entitled to inference royalties uint64 timestamp; // Registration time string metadata_uri; // Off-chain descriptor (IPFS, Arweave) } * * * **🧠 Off-Chain Metadata Example:** Copy { "name": "RWA-Yield-Optimizer-v1", "zk_format": "Halo2", "input_spec": "[APR, stake_volume]", "output_spec": "[reallocation_target]", "accuracy": 0.921, "rwa_token": "0xTokenizedModelERC20", "description": "Optimizes validator restaking using zkML." } * * * **🌍 RWA Integration:** * **Ownership Tokenization:** The `owner` address can be a smart contract that manages revenue splits to ERC-20 or NFT holders. * **Governance-Scoped Models:** DAOs can submit models and bind them to governance logic or yield policy. * **Usage Metering:** All inference calls are logged and traceable for performance-based monetization. > Once registered, the model becomes a **verifiable, composable, and revenue-capable digital asset** — optionally wrapped into an RWA token. [PreviousProgram Flow Overview](https://docs.hubic.ai/embark-upon/quickstart-3) [NextInference Request (User Job)](https://docs.hubic.ai/embark-upon/quickstart-3/inference-request-user-job) Last updated 1 month ago --- # Final Notes | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) Hubic redefines decentralized AI by embedding **zk-verified intelligence directly into Ethereum’s execution layer**. It turns inference into an auditable, monetizable, and composable primitive — enabling use cases from agent-driven DeFi to real-world asset tokenization. * * * **🧠 Key Characteristics:** * **Zero-trust architecture:** All AI outputs are cryptographically proven. * **Modular infrastructure:** Fully compatible with Ethereum L1 & L2s. * **RWA-native:** Models and agents can generate, distribute, and track on-chain income like any real-world financial asset. * **Composable logic:** DAOs, protocols, and dApps can plug into proof-verified automation without dependency on opaque systems. * * * > Hubic transforms verifiable computation into a protocol-level asset class — backed by math, enforced by Ethereum, and monetized as RWA. * * * [PreviousFuture Expansion Points](https://docs.hubic.ai/embark-upon/quickstart-2/future-expansion-points) [NextProgram Flow Overview](https://docs.hubic.ai/embark-upon/quickstart-3) Last updated 1 month ago --- # Hubic Intelligence Hub (Expanded) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FRNdiKSO24kjnsAla1iyD%252F6.png%3Falt%3Dmedia%26token%3D9e2f3a23-d732-4ae3-92d1-05de52a84ecb&width=768&dpr=4&quality=100&sign=a1300f29&sv=2) The **Hubic Intelligence Hub** is a permissionless, fully on-chain registry that indexes all key components of the protocol: `⦿ zk-compatible models.` `⦿ sovereign AI agents.` `⦿ inference proofs.` `⦿ capital strategies.` Deployed on Ethereum, the Hub functions as the **coordination layer** for all verifiable AI activity and RWA monetization. It ensures trustless lookups, historical auditability, and contract-level composability. * * * **📚 Registry Overview** Entity Metadata Stored **Model** zk hash, verifier address, owner, usage count, royalty config, RWA token ID **Agent** type, stake info, controller, activity state, memory hash **Inference** timestamp, model ref, proof hash, input/output hashes **Strategy** agent ID, actions taken, results, simulation digest, status Each entry is written to Ethereum storage using smart contracts and **Program-Derived Addresses (PDAs)** or equivalent resolver mappings, enabling efficient access by dApps and governance modules. * * * **🔁 Example API Query (Off-Chain Mirror)** While the canonical source of truth is Ethereum, a mirrored API is available for indexing layers: **GET** `/models/0xabc123` Copy { "model_hash": "0xabc123...", "verifier": "VerifierContract", "inference_count": 128, "trust_score": 96.2, "zk_format": "Halo2", "rwa_token": "0xRWAxTokenAddress", "description": "Yield Optimizer v1.3" } **GET** `/agents/0xAgent456` Copy { "agent_type": "GovernanceBot", "model_hash": "0xghi789", "executions": 53, "stake": "1500 HUB", "audit_log": "ipfs://.../agentLogs" } * * * **🌍 RWA Integration:** `⦿ RWA Token Binding: Each model or agent can be linked to an ERC-20/NFT representing yield rights.` `⦿ Audit-Grade Logs: Inference results and strategy actions are permanently recorded - forming the legal and economic basis for yield claims.` `⦿ DAO Dashboard: Third-Party tools can access agent or model performance via standardized schema.` > The Intelligence Hub is your source of truth for income-generating AI — whether you're a developer, DAO, enterprise or RWA fund. [PreviousGovernance System](https://docs.hubic.ai/embark-upon/quickstart-1/governance-system) [NextVisual System Map](https://docs.hubic.ai/embark-upon/quickstart-1/visual-system-map) Last updated 1 month ago --- # Verification Phase | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FaAL2rlXch7ny29TAR7Ks%252F7.png%3Falt%3Dmedia%26token%3D7b01a879-8673-4816-81ac-3af1dcf9cc43&width=768&dpr=4&quality=100&sign=dc7c0de8&sv=2) After the zk-proof is generated by the executor, it must be validated on-chain. This step is performed by a **Verifier Smart Contract on Ethereum**, ensuring that: * The model used is authorized and registered, * The input/output are consistent with the request, * The zk-proof is cryptographically correct. Only upon successful verification can any payment or downstream logic (like RWA royalty distribution) be triggered. * * * **🔐 Verifier Responsibilities:** Step Action 1\. Retrieve `InferenceRequest` Based on request ID or hashes 2\. Load model verifier key From `zkRegistry` or verifier reference 3\. Validate zk-proof Using the on-chain verifier logic 4\. Confirm `input_hash` + `output_hash` Must match expected values from the job 5\. Emit verification event Confirmation event used by settlement, dashboards, and RWA logic * * * **📦 Verified Inference Struct:** Copy struct VerifiedInference { bytes32 request_id; bytes32 model_hash; bytes32 proof_hash; bytes32 input_hash; bytes32 output_hash; uint64 verified_at; } All fields are cryptographically enforced and emitted in a verification log, allowing trustless downstream automation. * * * **🧠 zk-Proof Systems Supported:** * Halo2, Groth16, Plonk (modular verifier contracts) * Verifier addresses are registered per model in the zkRegistry * Supports both monolithic and recursive circuits * * * **🌍 RWA Integration:** * **Verification = Revenue Activation**: RWA-linked models/agents receive payment only after successful proof verification. * **Immutable Traceability**: Logs can be queried to track real-world asset performance and yield events. * **Regulatory Alignment**: Provides cryptographic evidence of every monetized AI action — auditable and timestamped. > The verifier contract is not just a filter — it’s the **gatekeeper of revenue** in a cryptographically enforced AI economy. [PreviousExecution Phase (Off-Chain)](https://docs.hubic.ai/embark-upon/quickstart-3/execution-phase-off-chain) [NextRewards & Settlement](https://docs.hubic.ai/embark-upon/quickstart-3/rewards-and-settlement) Last updated 1 month ago --- # Inference Request (User Job) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) Any user, DAO, or application can initiate a **verifiable AI task** by submitting an inference request. This request is cryptographically tied to: * A registered model, * The user’s input (hashed), * And a HUB token payment. Once submitted, the request enters the execution pipeline and becomes a **provable, revenue-generating event** within the system. * * * **🔁 Workflow:** 1. User selects a model from the on-chain registry. 2. Prepares input data (off-chain JSON, hashed on client side). 3. Sends `InferenceRequest` transaction with: * `model_hash` * `input_hash` * `payment_amount` (in HUB or stablecoin) 4. Job is queued for executors. * * * **📦 On-Chain Struct:** Copy struct InferenceRequest { bytes32 input_hash; // SHA-256 of user’s input bytes32 model_hash; // Tied to registered zk-model address user; // Sender address uint256 payment_amount; // In HUB uint64 timestamp; // Unix time } * * * **📥 Input Data Example (Off-Chain):** Copy { "APR": 6.42, "stake_volume": 125000, "risk_profile": "moderate" } This input is not stored on-chain, but its hash is used to validate the zk-proof. * * * **🌍 RWA Integration:** * **Payment Tracking:** Requests using RWA-tokenized models will trigger payout logic to token holders. * **Subscription-Based Access:** DAOs holding access tokens (NFTs) can submit requests without direct HUB payment (prepaid logic). * **Auditable Revenue:** Each request adds to the on-chain usage history of a model, powering dashboards, reputation, and financial reporting. > Every inference request is a cryptographic contract — linking a user’s intent, a model’s logic, and an on-chain monetization outcome. [PreviousModel Registration (One-Time)](https://docs.hubic.ai/embark-upon/quickstart-3/model-registration-one-time) [NextExecution Phase (Off-Chain)](https://docs.hubic.ai/embark-upon/quickstart-3/execution-phase-off-chain) Last updated 1 month ago --- # Proof-of-Weights (PoW2) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252F2hJ6yvZpkRylJTovcHpe%252F9.png%3Falt%3Dmedia%26token%3Dadd5ea99-72ad-466f-a199-4b88e8e41da1&width=768&dpr=4&quality=100&sign=5fcf1190&sv=2) **PoW2** is Hubic’s decentralized reputation and scoring system — a mechanism that ensures inference nodes, AI agents and validators are evaluated fairly and verifiably. All scoring logic is encapsulated in zk-circuits and the results are submitted on-chain via Ethereum smart contracts. This creates a **zero-trust reputation layer**, critical for routing tasks, adjusting payouts and powering RWA revenue models. * * * **🔁 Flow:** Copy Validator or Scorer → Local Evaluation via zk-circuit → zk-Proof + Score → Ethereum Verifier → Reputation Update * * * **📦 WeightSubmission Struct:** Copy struct WeightSubmission { address validator; bytes32 proof_hash; bytes32 scores_hash; bytes32 circuit_id; uint64 timestamp; string feedback_uri; } Each submission includes a zk-proof that the scoring circuit was executed correctly over a set of subjects (e.g., executors, models, agents). * * * **🔐 Security Benefits:** Feature Description **zk-Proof of Scoring** Proves that logic was executed fairly — prevents copy/fraud. **Validator Binding** Ties logic to validator address, avoiding reused calculations. **Auditable Results** All scores can be externally verified by dApps or DAOs. * * * **🌍 RWA Relevance:** `⦿ Score-Linked Revenue Distribution: Only high-performing models or agents (proven via zk-scoring) receive royalty shares.` `⦿ Yield Optimization: Investment DAOs can allocate capital to top-rated strategies or AI assets.` `⦿ Reputation-Drive Pricing: Higher reputation models may demand premium inference fees — creating market-based pricing for AI-based RWAs.` > Scoring is no longer subjective — it’s verifiable, transparent and tied directly to income. * * * This makes PoW2 a **key enforcement layer** for any economic system where AI models or agents act as tokenized revenue engines. Without PoW2, the RWA yield pipeline would lack accountability. [PreviousLiquid Strategy Engine (LSE)](https://docs.hubic.ai/embark-upon/quickstart-1/liquid-strategy-engine-lse) [NextGovernance System](https://docs.hubic.ai/embark-upon/quickstart-1/governance-system) Last updated 1 month ago --- # Execution Phase (Off-Chain) | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) After a user submits an inference request, an **executor node** picks it up from the job queue and performs the AI computation off-chain. To ensure verifiability, the executor runs the model as a zk-circuit and produces a cryptographic proof of correctness. This phase is computation-heavy and forms the **core trust-minimized processing layer** of the Hubic protocol. * * * **🛠️ Execution Workflow:** 1. Executor receives the request tied to a `model_hash`. 2. Loads the zk-circuit and model weights. 3. Fetches the input payload using its `input_hash` (off-chain). 4. Performs the AI inference using zk-compatible logic. 5. Generates a **zk-proof** of the execution. 6. Hashes the output and wraps the result into a verifiable package. * * * **📦 Result Package Submitted to Verifier:** Copy { "output": ["validator_07", "validator_21"], "zk_proof": "0xabc123...", "proof_hash": "0xdef456...", "output_hash": "0xghi789..." } * `zk_proof`: The full cryptographic proof for the inference * `output_hash`: SHA-256 hash of the inference result * `proof_hash`: Hash of the zk-proof data structure * * * **⚠️ Integrity Notes:** * If the output doesn’t match the model’s registered circuit logic, the proof will fail on-chain. * Only registered models with valid verification keys can be executed. * No inference = no reward. * * * **🌍 RWA Integration:** * **Yield Trigger Point:** This is where tokenized AI models generate the raw material for RWA-based revenue. * **Executor Accountability:** Performance metrics (e.g., latency, proof size, error rate) impact future task allocation and reputation. * **Pre-validation for Royalty Rights:** Only output packages that pass structural pre-checks will proceed to revenue distribution on-chain. > The execution phase is where AI meets cryptographic enforcement — creating the only kind of work that can be trusted, tokenized, and monetized. [PreviousInference Request (User Job)](https://docs.hubic.ai/embark-upon/quickstart-3/inference-request-user-job) [NextVerification Phase](https://docs.hubic.ai/embark-upon/quickstart-3/verification-phase) Last updated 1 month ago --- # Governance System | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) Hubic uses a **hybrid governance framework**, combining token-weighted voting, activity-based reputation and zk-verifiable contributions. Governance participants can propose, vote on and enforce protocol upgrades — including the onboarding of new models, agents or RWA-linked assets. Everything is on-chain, auditable and programmable. * * * **🧩 Voting Power = Capital + Contribution:** Component Weighting Factor **HUB Token Holdings** Base voting power **Execution Uptime** Activity score for executors and agents **Inference Quality** zk-scored model accuracy and task success rate **Proposal Participation** Historical governance engagement This blended metric ensures that both financial stake and verifiable technical contributions are represented. * * * **🗳 Proposal Lifecycle (Struct Example):** Copy struct Proposal { uint256 id; address proposer; string description; uint64 vote_start; uint64 vote_end; uint256 yes_votes; uint256 no_votes; bool executed; bytes32 model_ref; // optional zk-model reference } Each proposal can optionally reference a zk-model, making it possible to govern AI or RWA logic directly (e.g. adjust fees, deprecate models or update agent policies). * * * **🧠 Advanced Governance Features:** `⦿ zk-Reasoning Support:Proposals may require a zk-proof of rationale (e.g. scoring data or simulations).` `⦿ Epoch-Based Voting Weight: Aligns influence with recent activity.` `⦿ Model-Scoped Votes: Only stakeholders of specific models/agents can vote (ideal for RWA sub-governance).` * * * **🌍 RWA Relevance:** `⦿ DAO-Controlled RWA Models: Tokenized models can be governed by holders, with fees, rewards and strategies controlled via proposals.` `⦿ Royalty Configuration: Changes to payout ratios or staking thresholds can be triggered by RWA tokenholders.` `⦿ Auditable Governance: Every rule, action and proposal is traceable — critical for real-world compliance and legal integration.` > With Hubic, you don’t just stake on-chain — you govern real digital assets backed by computation. [PreviousProof-of-Weights (PoW2)](https://docs.hubic.ai/embark-upon/quickstart-1/proof-of-weights-pow2) [NextHubic Intelligence Hub (Expanded)](https://docs.hubic.ai/embark-upon/quickstart-1/hubic-intelligence-hub-expanded) Last updated 1 month ago --- # Optional Extensions | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) Hubic supports several **modular extensions** that enhance its usability in complex, privacy-sensitive, or DAO-regulated environments. These are optional features that sit on top of the core zkML + economic pipeline and can be **programmatically enabled** via smart contracts. * * * **🔐 1. Private Inference** For enterprise or regulated data workloads, Hubic supports confidential inference workflows: * Encrypted inputs/outputs stored via IPFS or Arweave. * zk-proofs still generated — but output hashes can be masked or gated. * Fully verifiable by DAO or regulatory contracts with privileged access. **Use case:** Insurance firms, private credit scoring, proprietary model deployments. * * * **📦 2. Batch & Subscription Jobs** Enable users or applications to prepay for multiple inference tasks in bulk: * Reduce per-call gas fees via aggregation. * Useful for high-frequency protocols (trading bots, validators, off-chain oracles). * Scheduled or interval-based batch execution. **Use case:** L2 zk-Rollup verifications, DeFi rebalancing strategies. * * * **🏛 3. DAO-Gated Inference** Only DAO-approved users or contracts may access specific models: * DAO can control who uses an inference pipeline. * Access NFTs or DAO whitelist gating mechanisms supported. * Voting can dynamically enable/disable model usage. **Use case:** DAO-controlled RWA credit models or governance advisory bots. * * * **🌍 RWA Enhancements:** Feature Value for RWA Ecosystem **Gated Model Access** RWA products with regulated licensing or usage quotas **Private Revenue Tracing** Masked but auditable earnings streams **Prepaid Access Passes** RWA token-based API licensing or utility access > These extensions turn Hubic from a protocol into a **platform** — giving DAOs, enterprises, and tokenized asset managers programmable control over how AI is used, monetized, and governed. [PreviousRewards & Settlement](https://docs.hubic.ai/embark-upon/quickstart-3/rewards-and-settlement) [NextKey Takeaways](https://docs.hubic.ai/embark-upon/quickstart-3/key-takeaways) Last updated 1 month ago --- # Rewards & Settlement | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252F2hJ6yvZpkRylJTovcHpe%252F9.png%3Falt%3Dmedia%26token%3Dadd5ea99-72ad-466f-a199-4b88e8e41da1&width=768&dpr=4&quality=100&sign=5fcf1190&sv=2) Once an inference is successfully verified on-chain, the **Settlement Contract** is triggered. It performs **deterministic, on-chain payment distribution** to all involved parties — model owner, executor, and verifier — using the original inference fee submitted by the user. This step guarantees that only **cryptographically proven computation is paid**, forming the economic foundation of both Hubic and any tokenized RWA model. * * * **💰 Default Distribution Breakdown (Per Inference):** Role Share Notes Model Owner **60%** Can be a wallet or RWA token contract Executor **20%** Paid for zk-inference and proof generation Verifier **20%** Paid for validating the zk-proof on Ethereum * * * **⚙️ Settlement Logic Flow:** 1. Verifier contract emits a `VerifiedInference` event. 2. Settlement contract reads the associated payment data from the original request. 3. It distributes the HUB (or USDC/ETH if multi-token enabled) to: * Registered model owner address * Executor wallet * Verifier node 4. Emits `InferenceSettled` log with all payment receipts. * * * **🧾 Example Payout (Job = 100 HUB):** * `60 HUB` → model owner (or RWA smart contract) * `20 HUB` → executor * `20 HUB` → verifier All payments are atomic and final. * * * **⛓ On-Chain Record:** Every settlement is stored immutably and indexed by: * `request_id` * `model_hash` * `payer` * `timestamp` * payout recipients + values This ensures compatibility with reputation scoring, DAO transparency, and RWA audit/reporting layers. * * * **🌍 RWA Integration:** * **Auto-Streaming to RWA Holders:** Model owners can register an ERC-20 or ERC-721 payout contract that distributes revenue to token holders (e.g. via Superfluid or streaming vaults). * **Performance-Linked Yield:** RWA dashboards can show real-time yield generated by model usage and task volume. * **Composable Revenue Sharing:** Smart contracts can split model owner fees across DAOs, LPs, dev teams, or token holders. > Settlement turns AI into an income-generating asset — where math, not trust, guarantees payment. [PreviousVerification Phase](https://docs.hubic.ai/embark-upon/quickstart-3/verification-phase) [NextOptional Extensions](https://docs.hubic.ai/embark-upon/quickstart-3/optional-extensions) Last updated 1 month ago --- # Key Takeaways | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FUerHUnVECzwCvaEdHBwP%252F2.png%3Falt%3Dmedia%26token%3D3c0499f3-fd81-4fd3-9567-e585668b0103&width=768&dpr=4&quality=100&sign=36768995&sv=2) Hubic transforms AI inference from a black-box process into a **fully verifiable, composable, and monetizable layer** of on-chain logic. Built for Ethereum and engineered for scale, it enables: * **Zero-trust execution pipelines** using zero-knowledge proofs. * **On-chain economic enforcement** for inference, scoring, and royalties. * **Native support for tokenized AI assets** — making AI models and agents RWA-compatible. **🔐 Security** * zk-proofs validate every output — no trust required in executors or validators. * Slashing logic + audit trails ensure correctness and accountability. **⚙️ Automation** * zk-verified agents execute DAO votes, DeFi logic, or RWA flows autonomously. * On-chain contracts react to proof-verified model outputs in real time. **💰 Monetization** * Inference = Revenue. * Every verified job routes income to model owners, executors, and verifiers. * RWA tokens enable shared ownership over AI model yield streams. **📊 Transparency** * All inference jobs, payments, and reputation metrics are recorded immutably on Ethereum. * Fully auditable by DAOs, funds, users, or regulators. > **Hubic redefines what it means to trust AI — not by authority, but by cryptography.** In this new paradigm, every model, every task, and every payout is proven, enforceable, and financialized. [PreviousOptional Extensions](https://docs.hubic.ai/embark-upon/quickstart-3/optional-extensions) [NextReal-World Use Case Example](https://docs.hubic.ai/embark-upon/quickstart-4) Last updated 1 month ago --- # Real-World Use Case Example | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FlCWtKQCmj8Cz6mPleZEg%252F5.png%3Falt%3Dmedia%26token%3Db44ae18f-9d36-4764-9dbf-b7b21493f79c&width=768&dpr=4&quality=100&sign=cfb63ad4&sv=2) This section demonstrates how the Hubic protocol can be applied in a real-world, high-value context — where inference isn’t just logic, but **monetizable computation**, **governed automation**, and **tokenized output**. The focus of this example is a **DAO managing validator delegation** on Ethereum. Through zkML, verifiable agents, and RWA integration, we’ll show how a DAO can: * Replace human-driven delegation logic with AI agents. * Ensure every decision is cryptographically proven. * Transform its model into an income-generating asset through tokenization. * * * **💡 Why This Matters** Most DAOs rely on off-chain heuristics, manual voting, or opaque bots for complex tasks like capital rotation. These systems are: * **Not verifiable** * **Not monetizable** * **Not composable** Hubic enables an alternative: → AI agents that can be **governed**, **tokenized**, and **proven**. → Every DAO action is backed by **zk-proofs**. → Every model becomes a **productive, traceable, and shareable digital asset**. * * * > This section walks through how a DAO can use Hubic to automate validator restaking decisions — while turning the underlying model into a Real World Asset. [PreviousKey Takeaways](https://docs.hubic.ai/embark-upon/quickstart-3/key-takeaways) [NextIntroduction](https://docs.hubic.ai/embark-upon/quickstart-4/introduction) Last updated 1 month ago --- # Introduction | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) Validator delegation strategies within Ethereum DAOs are often based on informal heuristics, periodic governance votes, or centralized dashboards. This leads to inefficiencies, delayed reactions to performance fluctuations, and missed staking rewards. **Hubic enables DAOs to replace manual delegation with autonomous AI agents** that: * Operate on zk-verified logic, * Are provably correct, * Can be tokenized as Real World Assets (RWAs). * * * **🎯 Scenario Overview** A DAO managing a large ETH treasury wants to maximize staking yield while minimizing exposure to downtime or slashing. Instead of: * Manually evaluating validator stats, * Proposing reallocation votes, * Or outsourcing to centralized bots, the DAO uses a **zk-model registered on Hubic** to automate this logic in a fully transparent, programmable, and revenue-generating way. * * * **💼 Real-World Impact:** * **Faster reallocation based on verifiable data** * **AI agent can be tokenized → DAO earns revenue from model usage** * **All logic is on-chain, transparent, and composable with DeFi or RWA flows** > This use case shows how verifiable AI agents can power DAO governance, optimize treasury returns, and serve as monetizable infrastructure via RWA tokenization. [PreviousReal-World Use Case Example](https://docs.hubic.ai/embark-upon/quickstart-4) [NextProblem Statement](https://docs.hubic.ai/embark-upon/quickstart-4/problem-statement) Last updated 1 month ago --- # Problem Statement | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FRNdiKSO24kjnsAla1iyD%252F6.png%3Falt%3Dmedia%26token%3D9e2f3a23-d732-4ae3-92d1-05de52a84ecb&width=768&dpr=4&quality=100&sign=a1300f29&sv=2) DAOs managing validator delegation on Ethereum or staking platforms face several structural challenges: * * * **⚠️ 1. Static Logic, Manual Updates** Delegation strategies often rely on: * Fixed thresholds or scripts, * Infrequent proposal cycles, * Delays between metric change and action. This leads to **underperformance** in dynamic markets. * * * **⚠️ 2. Zero Auditability** AI bots (where used) are: * Opaque, * Not verifiable, * Impossible to trust or govern. DAOs cannot prove that delegation logic was correct — only that it was _executed_. * * * **⚠️ 3. No Monetization of Strategy** Even if an off-chain agent is accurate: * It earns no revenue, * Has no on-chain value, * And cannot be governed, shared, or sold. DAOs lack the infrastructure to **tokenize their intelligence**. * * * #### [](https://docs.hubic.ai/embark-upon/quickstart-4/problem-statement#core-pain-points-recap) 🔍 Core Pain Points Recap: Challenge Description Performance Drift Validator uptime/APR changes rapidly — logic lags behind Slashing Risk Delegating to unstable validators → lost yield Lack of Verifiability No proof of why or how decisions were made No Assetization Path AI agents can't generate revenue or act as economic units * * * > Hubic solves these gaps with zk-inference pipelines and RWA-enabled agents — where every model is verifiable, composable, and monetizable. [PreviousIntroduction](https://docs.hubic.ai/embark-upon/quickstart-4/introduction) [NextSystem Actors](https://docs.hubic.ai/embark-upon/quickstart-4/system-actors) Last updated 1 month ago --- # System Actors | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252F2hJ6yvZpkRylJTovcHpe%252F9.png%3Falt%3Dmedia%26token%3Dadd5ea99-72ad-466f-a199-4b88e8e41da1&width=768&dpr=4&quality=100&sign=5fcf1190&sv=2) This use case involves a minimal but powerful set of actors working together through zk-proven logic and smart contract enforcement. Each role contributes to execution, validation, and monetization — enabling the DAO to operate in a fully trustless, composable, and revenue-generating way. * * * **🧠 Actors & Roles:** **Actor** **Function** **DAO Smart Contract** Triggers delegation requests and executes validator reallocation logic post-verification **zk-Model (RWA Asset)** A tokenized model that ranks validators based on uptime, slashing, APR, etc. **Executor** Runs inference off-chain using zk-circuit, returns result + proof **Validator Node** Verifies zk-proof and confirms model-output consistency on-chain **zkRegistry** Holds model metadata, proof format, verifier address, and (optionally) RWA token linkage **RWA Token Contract** Receives the model revenue share and distributes to token holders * * * **💡 Example Tokenized Model:** A model called `Hubic-RWA-StakeOpt` is registered on-chain with: * Inference fee: 1.0 HUB per job * Ownership fractionalized via `StakeOptToken` (ERC-20) * DAO uses it to rebalance 250K+ ETH across top validators * * * **🔄 Interaction Summary:** * DAO issues an inference job with validator performance inputs * zk-model runs off-chain, proof generated * Proof verified on Ethereum * DAO reallocates stake based on result * Model earns revenue, streamed to RWA token holders * * * > Every actor is trustless, programmable, and incentivized. And every model, if tokenized, becomes part of a real economic feedback loop. [PreviousProblem Statement](https://docs.hubic.ai/embark-upon/quickstart-4/problem-statement) [NextEnd-to-End Flow: DAO Delegation Automation](https://docs.hubic.ai/embark-upon/quickstart-4/end-to-end-flow-dao-delegation-automation) Last updated 1 month ago --- # End-to-End Flow: DAO Delegation Automation | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FMiloCV4pc3OQ2XzPbUQX%252F8.png%3Falt%3Dmedia%26token%3Df35b6163-f25f-4150-9d97-454d1e548d1b&width=768&dpr=4&quality=100&sign=a6c442a3&sv=2) This section illustrates how a DAO can execute **trustless, tokenizable validator delegation** using a zk-model deployed through Hubic. Each step is verifiable, monetizable and enforceable on Ethereum. * * * **🌀 Phase 1: Metrics Collection** The DAO compiles a dataset of validator metrics such as: * 30-day uptime, * Recent slashing incidents, * Average staking APR, * MEV activity or commission rates. → The dataset is hashed (`input_hash`) and submitted as part of an inference request. * * * **📦 Example Input Payload:** Copy { "validators": [\ {"id": "0xA1", "uptime": 0.97, "apr": 5.4, "slashed": false},\ {"id": "0xC2", "uptime": 0.92, "apr": 5.9, "slashed": true}\ ] } * * * **🌀 Phase 2: Model Selection & Dispatch** * DAO references a pre-approved zk-model (`model_hash`) from the Hubic zkRegistry. * Validator contract dispatches the task to an executor node. * Model: `Hubic-RWA-StakeOpt v1.2` * RWA Token: `StakeOptToken` * * * **🌀 Phase 3: zk-Inference Execution** * Executor loads the model. * Runs zk-circuit with DAO-provided input. * Produces `zk-proof`, `output_hash`, `proof_hash`. * * * **🌀 Phase 4: On-Chain Verification** * Verifier contract checks: * Model hash matches registry * zk-proof is valid * Input/output integrity is preserved * Emits `InferenceVerified` event: Copy event InferenceVerified { bytes32 model_hash; address dao; bytes32 input_hash; bytes32 output_hash; bool success; } * * * **🌀 Phase 5: DAO Stake Reallocation** * DAO smart contract reads verified output (e.g., top 3 validators). * Triggers capital movement via staking/re-delegation logic. * Records action in DAO log for governance transparency. * * * **🌀 Phase 6: Revenue Settlement** * Model owner receives 60% of the inference fee (e.g., 0.6 HUB). * If tokenized, the fee is routed to `StakeOptToken` contract. * Token holders receive proportional share via payout contract. * * * > From input to execution to payout, every action is backed by math, traceable by DAO, and monetizable through RWA logic. [PreviousSystem Actors](https://docs.hubic.ai/embark-upon/quickstart-4/system-actors) [NextBenefits to DAO Operations](https://docs.hubic.ai/embark-upon/quickstart-4/benefits-to-dao-operations) Last updated 1 month ago --- # Benefits to DAO Operations | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FaAL2rlXch7ny29TAR7Ks%252F7.png%3Falt%3Dmedia%26token%3D7b01a879-8673-4816-81ac-3af1dcf9cc43&width=768&dpr=4&quality=100&sign=dc7c0de8&sv=2) Using Hubic, a DAO can automate its validator delegation logic while transforming the process into a **verifiable, auditable, and income-generating asset**. This creates alignment between operational efficiency, governance transparency, and RWA-based yield. * * * **✅ Operational Advantages** Benefit Description **End-to-End Automation** From input submission to reallocation, no manual steps or off-chain risk. **Proof-Based Execution** All decisions are backed by zk-proofs, not heuristics or unverifiable code. **Fast Delegation Cycles** Restaking logic can trigger daily/hourly based on on-chain DAO parameters. **Composability** Agents can be extended to treasury, lending, insurance or other modules. * * * **📊 Governance & Transparency** * DAO members can **verify every decision path** via smart contract logs and input hashes. * Proposals can reference **previously proven inference results**. * Model usage can be **scoped to DAO votes** — enforcing decentralized control over automation. * * * **💰 Monetization via RWA** * AI model becomes a **yield-generating asset** through inference fees. * Token holders of the model's RWA receive **streamed revenue** as long as the model is used. * DAOs may **sell, license, or govern** their own strategy models via RWA tokenization. * * * > Hubic enables DAOs to operate not just more efficiently, but **economically — where logic earns, and decisions prove themselves.** [PreviousEnd-to-End Flow: DAO Delegation Automation](https://docs.hubic.ai/embark-upon/quickstart-4/end-to-end-flow-dao-delegation-automation) [NextExtensions & Advanced Use](https://docs.hubic.ai/embark-upon/quickstart-4/extensions-and-advanced-use) Last updated 1 month ago --- # Extensions & Advanced Use | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252F2hJ6yvZpkRylJTovcHpe%252F9.png%3Falt%3Dmedia%26token%3Dadd5ea99-72ad-466f-a199-4b88e8e41da1&width=768&dpr=4&quality=100&sign=5fcf1190&sv=2) The DAO delegation use case is just one vertical. Hubic’s composable architecture enables DAOs and RWA token holders to expand the model far beyond validator selection — into a general framework for intelligent, revenue-generating on-chain infrastructure. * * * **🌐 Multi-Chain Delegation** * Extend model logic to support validator reallocation across: * Ethereum mainnet * L2s like Arbitrum or Optimism * Restaking via EigenLayer or Babylon * Bridge results and proofs using cross-chain messaging (e.g. LayerZero, Axelar). * * * **🧠 Multi-Agent Pipelines** * Combine agents for delegation, governance, and treasury logic: * `RestakeAgent` → validator allocation * `GovBot` → DAO proposal generation * `YieldBalancer` → treasury rebalancing * All coordinated via zk-proven inputs and shared state commitments. * * * **⏱ Epoch-Based Automation** * Use slot or epoch triggers to: * Auto-submit inference jobs * Execute staking changes only if performance drops * Limit model usage to governance-approved intervals * * * **🔐 DAO-Gated Inference** * Limit model access to specific DAO members or contracts * Integrate with `accessControlNFTs` or `governanceRoles()` * Lock strategic models behind membership or governance quorum * * * **🌍 RWA-Specific Additions** Feature Value for RWA Use **On-chain yield tracking** Dashboards show tokenized yield per model per epoch. **DAO-managed models** Treasury holds model as productive asset. **Secondary marketability** RWA tokens tradable on DEXs or integrated into LP pools. * * * > This framework can be applied to trading, insurance pricing, cross-chain lending, compliance scoring — any domain where **AI needs to be proven, governable and profitable.** [PreviousBenefits to DAO Operations](https://docs.hubic.ai/embark-upon/quickstart-4/benefits-to-dao-operations) [NextTokenomics](https://docs.hubic.ai/hubic-economic-engine/quickstart) Last updated 1 month ago --- # Roadmap | Hubic.ai #### [](https://docs.hubic.ai/hubic-economic-engine/quickstart-1#undefined) ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252Fix6g43v3bm1zKVyFHq1d%252F3.png%3Falt%3Dmedia%26token%3Db2398eb5-3484-43ff-97e3-450226e600ba&width=768&dpr=4&quality=100&sign=d1d4657c&sv=2) #### [](https://docs.hubic.ai/hubic-economic-engine/quickstart-1#phase-i-core-protocol-deployment-q2-q3-2025) 🧱 Phase I — Core Protocol Deployment (Q2–Q3 2025) > Establish the zkML execution pipeline on Ethereum and enable verifiable AI inference as a programmable service. **Goals:** * ✅ Deploy `zkRegistry` (model metadata, hashes, verifier contracts) * ✅ Launch `InferenceRequest` + `ProofVerification` smart contracts * ✅ Integrate support for Halo2 / Groth16 / Plonk zk formats * ✅ Release open-source executor client + inference CLI * ✅ Tokenize first production AI model as RWA (`ERC-20` ownership contract) * ✅ Settlement module for revenue routing (Model Owner / Executor / Verifier) * * * #### [](https://docs.hubic.ai/hubic-economic-engine/quickstart-1#phase-ii-agent-infrastructure-and-dao-integration-q3-q4-2025) ⚙️ Phase II — Agent Infrastructure & DAO Integration (Q3–Q4 2025) > Enable sovereign zk-agents to operate on-chain with DAO governance and RWA-linked revenue models. **Goals:** * 🔄 Launch `SovereignAgent` framework (staking, task execution, memory) * 🧠 Deploy `LiquidStrategyEngine` for DeFi strategy execution * 🏛 DAO-linked governance logic with zk-proposal rationales * 🌍 Support tokenized access to models (`ERC-721` licensing, gating) * 📊 RWA dashboards: yield tracking + proof analytics per tokenized model * 🤝 Integrate with DAO tooling (Snapshot, Tally) for agent-sourced proposals * * * #### [](https://docs.hubic.ai/hubic-economic-engine/quickstart-1#phase-iii-cross-chain-and-enterprise-scale-q1-2026-onward) 🌐 Phase III — Cross-Chain & Enterprise Scale (Q1 2026 onward) > Expand Hubic into a cross-domain, enterprise-ready AI compute and monetization layer. **Goals:** * 🪐 L2 & Rollup integration (Optimism, Arbitrum, Base, zkSync) * 🌉 Cross-chain inference bridges (EigenLayer, LayerZero, Axelar) * 🔐 Private inference support: encrypted payloads + shielded outputs * 🧾 zkBilling + zkSLA proofs for enterprise use * 💼 Enterprise-tier deployment packages (custom access, SLAs, analytics) * 🧭 Model reputation NFTs + zk-credential issuance for node operators * * * > ⚡️ Long-Term Vision: **Hubic = The zkML protocol layer for tokenizing intelligence itself** — from AI capital strategies and DAO governance agents, to revenue-generating models that live and operate as decentralized RWAs. [PreviousTokenomics](https://docs.hubic.ai/hubic-economic-engine/quickstart) Last updated 1 month ago --- # Tokenomics | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) #### [](https://docs.hubic.ai/hubic-economic-engine/quickstart#hub-tokenomics-overview) HUB Tokenomics Overview **Category** **Allocation** **Amount (HUB)** Liquidity Pool 60% 60,000,000 Ecosystem Rewards 20% 20,000,000 Partnerships, Market Making, Listings, Ambassadors & Advisors 15% 15,000,000 Contingency Reserve 5% 5,000,000 **Total Supply** **100%** **100,000,000** The HUB token has a total supply of 100 million. Here's how it's distributed: * **60%** goes to **Liquidity Pool** to keep trading smooth and stable. * **20%** is for **Ecosystem Rewards**, helping to grow the community and reward participation. * **15%** supports **Partnerships, Listings, Market Making, Ambassadors, and Advisors**, helping HUB expand and reach more people. * **5%** is held in a **Contingency Reserve** to cover any unexpected needs in the future. This distribution is designed to support a strong, active ecosystem and long-term project success. `**Contract Address:**``(soon)` [PreviousExtensions & Advanced Use](https://docs.hubic.ai/embark-upon/quickstart-4/extensions-and-advanced-use) [NextRoadmap](https://docs.hubic.ai/hubic-economic-engine/quickstart-1) Last updated 1 month ago --- # Introduction | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) **Hubic is an Ethereum-native protocol enabling cryptographically verifiable AI computation within a decentralized, trust-minimized execution framework.** It operates as an off-chain inference layer for zk-compatible AI models, producing outputs that are verifiable on-chain through Ethereum smart contracts. Unlike traditional AI services that rely on opaque APIs or centralized infrastructure, Hubic ensures: * `All AI predictions are accompanied by zero-knowledge proofs.` * `Verifiability of models and outputs via on-chain logic.` * `Full composability with on-chain agents, DAOs and financial primitives.` By embedding zero-knowledge proofs into AI inference workflows, Hubic unlocks transparent, auditable and scalable AI automation — including for Real World Asset (RWA) strategies where tokenized AI models produce provable, revenue-generating outputs. **Key Benefits:** * `**AI as Verifiable Infrastructure - Each output is tied to a zk-proof.**` * `**Ethereum-Native Agents - Integration with DAOs, DeFi and governance logic.**` * `**RWA Integration - Tokenized models and agents as income-bearing on-chain assets.**` Hubic is designed to serve as a foundational layer for trustless AI coordination — from agent-based finance to automated capital deployment — with Ethereum's battle-tested security and composability at its core. [PreviousHubic AI](https://docs.hubic.ai/) [NextProof-of-Inference (PoI)](https://docs.hubic.ai/embark-upon/quickstart/proof-of-inference-poi) Last updated 1 month ago --- # Tokenomics | Hubic.ai ![](https://docs.hubic.ai/~gitbook/image?url=https%3A%2F%2F2416513212-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F94AaovEik9iNDWCzbuS3%252Fuploads%252FAjtvgAVb5NsSW9CszgHQ%252F1.png%3Falt%3Dmedia%26token%3D05b14667-1acb-4567-8886-b42741256e36&width=768&dpr=4&quality=100&sign=20145c24&sv=2) #### [](https://docs.hubic.ai/hubic-economic-engine#hub-tokenomics-overview) HUB Tokenomics Overview **Category** **Allocation** **Amount (HUB)** Liquidity Pool 60% 60,000,000 Ecosystem Rewards 20% 20,000,000 Partnerships, Market Making, Listings, Ambassadors & Advisors 15% 15,000,000 Contingency Reserve 5% 5,000,000 **Total Supply** **100%** **100,000,000** The HUB token has a total supply of 100 million. Here's how it's distributed: * **60%** goes to **Liquidity Pool** to keep trading smooth and stable. * **20%** is for **Ecosystem Rewards**, helping to grow the community and reward participation. * **15%** supports **Partnerships, Listings, Market Making, Ambassadors, and Advisors**, helping HUB expand and reach more people. * **5%** is held in a **Contingency Reserve** to cover any unexpected needs in the future. This distribution is designed to support a strong, active ecosystem and long-term project success. `**Contract Address:**``(soon)` [PreviousExtensions & Advanced Use](https://docs.hubic.ai/embark-upon/quickstart-4/extensions-and-advanced-use) [NextRoadmap](https://docs.hubic.ai/hubic-economic-engine/quickstart-1) Last updated 1 month ago ---