👋 Welcome to the Ciro Network Community!

We’re so glad you found us. Whether you’re a developer, GPU provider, researcher, builder, or just curious about the future of decentralized AI, you belong here. Ciro is a place for everyone who believes in open, verifiable, and accessible compute—no matter your background or experience.

Our community is global, inclusive, and always ready to help. We’re united by a shared vision: to make powerful, trustworthy AI and compute available to all, not just the privileged few. If you want to build, contribute, learn, or simply explore, you’re in the right place.

• New to Web3 or AI? No problem—our guides and community are here for you.
• Seasoned developer or GPU pro? Dive in and help shape the future.
• Curious about decentralized infrastructure? You’re in the right place.

Let’s build the future of verifiable compute—together.

Welcome to Ciro

TL;DR: Ciro Network is a decentralized compute layer for real-time AI and ZK workloads, built on Starknet and proven in industrial production environments. Think AWS compute meets DeFi economics, but with mathematical proofs and global reach.

🧬 What We're Building

In one sentence: A verifiable compute protocol that transforms underutilized GPUs into a global, trustless supercomputer for AI workloads.

In one paragraph: Ciro Network orchestrates distributed GPU resources through cryptographic proofs, enabling enterprises to access verifiable compute that traditional cloud providers simply cannot offer. Built on Starknet with ZK-ML verification, every inference, training job, and proof generation is both economically efficient and cryptographically sound.

In one page: The future of AI compute is not centralized data centers—it's an intelligent mesh of distributed resources, coordinated by economic incentives and secured by zero-knowledge proofs. Ciro Network is that future, operational today. Born from real industrial necessity and battle-tested in production environments, Ciro is designed for engineers, researchers, and organizations who demand verifiable, censorship-resistant, and cost-efficient compute for real-world AI and ZK workloads.

🔥 Born From Necessity

Ciro wasn't born in a hackathon—it was born on the factory floor.

When our computer vision systems for Latin American industrial plants hit $60,000/month AWS surges, we faced a choice: accept the economic brutality of centralized compute, or build something smarter. Our industrial vision systems were processing thousands of defect detection jobs daily, but centralized clouds were draining resources faster than we could scale.

We chose to build.

First for ourselves. Then for the world.

The result? A protocol achieving 15,000 transactions per second on Starknet testnet, with sub-200ms latency and production-ready architecture. Currently in final testing phase before mainnet deployment to real factories, production lines, and enterprise environments.

⚡ Why This Matters

🔬 Scientific Sovereignty

AI shouldn't require permission from hyperscale clouds. Researchers, startups, and enterprises deserve compute sovereignty—the ability to run AI workloads without vendor lock-in, geographic restrictions, or opaque pricing. When compute infrastructure becomes a bottleneck to innovation, progress stagnates.

🌍 Economic Liberation

The current compute oligopoly wastes resources while inflating costs. Centralized providers charge premium rates while millions of GPUs sit idle globally. Ciro creates a more efficient market that redistributes value to GPU owners worldwide, enabling competitive pricing through genuine market dynamics rather than corporate markup.

🛡️ Verifiable Truth

In an era of AI hallucinations and deepfakes, Ciro provides mathematical proof that your AI computations are correct. Every inference carries a ZK-proof of validity—no trust required. When your model says a medical scan is clear or a financial transaction is valid, you need more than "trust us."

🚀 Unstoppable Innovation

Decentralized compute accelerates AI development by removing barriers to experimentation. When compute is abundant and affordable, innovation flourishes. When it's scarce and expensive, only the biggest players can participate.

📊 The Reality Check

Ciro's strategic advantage: While competitors compete on price or specialization, Ciro enables provably correct computation—unlocking new markets like DeFi AI and on-chain gaming that require cryptographic guarantees.

Performance Metrics That Matter

• 15,000 transactions per second achieved in optimized testnet conditions (Mainnet: ~127 TPS sustained)
• Sub-200ms latency demonstrated in distributed test environments
• Production-ready architecture validated through comprehensive testing
• Competitive pricing targeting $1.40-2.20/H100-hour vs. AWS $4.10+ and Azure $6.98+

🤝 Who is Ciro For?

🏗️ Starknet dApp Developers

Who need affordable AI inference integrated directly into their smart contracts. Our JobManager contract handles job submission, escrow, and payment settlement on-chain, while the Paymaster enables gas-free transactions for end users. Perfect for DeFi protocols adding ML-based risk analysis, gaming dApps with AI NPCs, or any application requiring real-time intelligence.

🔬 AI/ML Engineers & Researchers

Who need verifiable compute for diverse AI workloads without vendor lock-in. Our smart contracts support 13 specialized job types: AI Inference, AI Training, Computer Vision, NLP, Audio Processing, Time Series Analysis, Multimodal AI, Reinforcement Learning, Specialized AI, Proof Generation, Proof Verification, Data Processing, and Custom models. Submit jobs with framework-specific dependencies (TensorFlow, PyTorch, ONNX, etc.) and hardware requirements via Cairo contracts with cryptographic execution guarantees.

⚡ GPU Providers (Individual & Enterprise)

Who want to monetize idle hardware through our CDC Pool staking system. Register workers with 8 hardware capability flags: CUDA, OpenCL, FP16, INT8, NVLink, InfiniBand, Tensor Cores, and Multi-GPU support. Our tiered system supports everyone from basic GPU owners ($100 minimum stake) to institutional data centers ($500K+ stakes). Capability-based job matching ensures optimal resource utilization, while smart contract-based slashing and reputation scoring protect network integrity.

🏭 ZK Infrastructure Providers

Who need high-performance proof generation for Starknet and other rollups. Our ProofVerifier contract specializes in recursive proofs, batch processing, and cross-chain bridge verification. Priority-based job allocation ensures critical blockchain infrastructure stays operational, with USD-denominated rewards for time-sensitive proof generation.

🌐 Web3 Infrastructure Teams

Who want to build on protocol-native, verifiable compute. Deploy applications that inherit the sovereignty and cryptographic guarantees of their compute layer. Our smart contracts provide escrow, dispute resolution, and automated payment distribution—eliminating the need to trust centralized compute providers.

🎮 Game Developers & Creative Studios

Who need compute for AI-powered NPCs, procedural generation, and real-time rendering workloads. Our Custom and MultimodalAI job types support Unity/Unreal Engine integration, dynamic NPC behavior, intelligent game balancing, and adaptive content generation. Framework dependencies support popular game AI libraries with hardware matching for Multi-GPU and Tensor Core requirements. Gas-free transactions via Paymaster ensure seamless player experiences.

🎨 Digital Artists & Content Creators

Who require GPU compute for artistic generation, video rendering, and audio composition. Our smart contracts comprehensively support:

• Custom Job Types for specialized artistic AI models (Stable Diffusion, DALL-E derivatives, MidJourney-style workflows)
• MultimodalAI capabilities for text-to-image, image-to-video, and cross-modal artistic generation
• AudioProcessing jobs for AI music composition, voice synthesis, and audio enhancement
• Video Rendering through custom model requirements supporting high-memory GPU configurations
• Framework Dependencies for popular creative AI frameworks (ComfyUI, Automatic1111, RunPod workflows, FFmpeg processing)
• Hardware Capability Matching with Tensor Cores, Multi-GPU setups, and specialized GPU memory requirements for 4K/8K content creation

🏢 Enterprise Operations

Who require auditable, cost-predictable compute for regulated workloads. Manufacturing quality control, financial risk analysis, medical imaging—domains where computational integrity is mandatory. Our Cairo contracts provide complete audit trails of job execution, payments, and verification proofs for compliance requirements.

🎯 Technical Elegance

Ciro achieves this through three core innovations:

🧠 ZK-ML Verification

Every AI computation generates a STARK proof of correctness, verified on Starknet in ~2 seconds. Not just attestations or hash commitments—mathematical proof that your inference was computed correctly on the specified model with the given inputs.

⚡ Hybrid Orchestration

Smart routing between on-premises, edge, and network resources based on latency, cost, and security requirements. Your workload automatically finds the optimal compute environment without manual configuration.

💎 Economic Design

Token-curated registry of compute providers with slashing conditions for malicious behavior and rewards for performance. Economics aligned for reliability, not just lowest price.

🛠️ Built for Reality

Unlike theoretical compute protocols, Ciro emerged from real-world usage:

🏭 Industrial Vision

Object detection on assembly lines processing thousands of items per hour. When a false negative costs $10K in defective products, verification isn't academic—it's economic survival.

🏥 Medical AI

HIPAA-compliant diagnostic imaging where patient safety demands both privacy and accuracy. Decentralized compute with cryptographic guarantees meets regulatory requirements that centralized clouds struggle with.

💰 Financial Models

Risk analysis for emerging markets where data sovereignty and computational auditability aren't optional features—they're legal requirements.

🔬 Research Computing

Training smaller models on federated data where compute costs can't exceed research grants, but results need to be reproducible and verifiable.

Each use case taught us what actually matters: reliability, verifiability, and economic sustainability. Not just theoretical scalability or benchmark performance.

🌐 The Network Effect

Ciro's power grows with its network:

Provider Diversity

From gaming rigs in bedrooms to enterprise data centers, every GPU can contribute. Geographic and economic diversity creates resilience that no single cloud provider can match.

Workload Intelligence

The network learns optimal placement for different workload types. Computer vision jobs route to providers with appropriate memory bandwidth. Training jobs find the lowest-latency multi-GPU clusters.

Economic Efficiency

Market forces drive prices down while reliability requirements drive quality up. Providers compete on performance metrics, not marketing budgets.

🚀 Technical Architecture Deep Dive

For those who want to understand how the magic happens:

Smart Contract Layer (Cairo on Starknet)

• JobManager: Job submission, worker assignment, and payment escrow for AI/ML and ZK proof workloads
• CDC_Pool: Worker registration, CIRO token staking (8 tiers: $100-$500K), and reputation-based job allocation
• CIRO_Token: ERC20 with governance, progressive burn mechanisms (30%→80% fee burns), and security budget protection
• Paymaster: Gas-free transactions for IoT devices and seamless dApp integration

Orchestration Layer (Rust)

• Kafka-based job queuing supporting 13 AI job types (Computer Vision, NLP, Audio Processing, Time Series Analysis, Multimodal AI, Reinforcement Learning, etc.)
• Advanced worker capability matching: 8 hardware flags (CUDA, OpenCL, FP16, INT8, NVLink, InfiniBand, Tensor Cores, Multi-GPU)
• Framework dependency resolution (TensorFlow, PyTorch, ONNX, custom frameworks)
• P2P networking with libp2p for decentralized worker discovery and heartbeat systems

Verification Layer (ZK-STARK)

• ProofVerifier contract supporting 5 proof types: Starknet Batch, Recursive Proof, zkML Inference, Cross-Chain Bridge, Application-Specific
• Integration with Giza/Orion for zkML inference verification with 4 priority levels (Standard, High, Critical, Emergency)
• Multi-party consensus validation and statistical sampling for different verification methods
• On-chain slashing for invalid proof submissions with cryptographic evidence handling

Provider Layer (Docker + GPU)

• Rust-based worker nodes with CUDA/OpenCL capability detection
• Secure model deployment with hash-based verification
• Performance metrics tracking (completion rate, response time, quality scores)
• Tiered staking system aligning incentives with hardware investment

🌟 What's Next?

Ready to experience verifiable compute? Choose your path:

→ 🚀 Getting Started – Run your first job in 3 minutes
→ 🔧 Tech Architecture – Deep dive into ZK-ML and orchestration
→ 💰 Tokenomics – Understand the economic design
→ 🤝 Contribute – Join the network as a provider or developer

Ciro Network: Where mathematics meets market forces to democratize AI compute.

The future isn't centralized. It's verified.

🌟 Our Vision: AI Belongs to Everyone

“We built Ciro because the future of intelligence should be open, verifiable, and shared by all.”

✨ The Dream That Drives Us

Imagine a world where the power of AI is not locked behind corporate gates, but flows freely—like electricity—reaching every builder, dreamer, and community on Earth. Where a student in Lagos, a researcher in São Paulo, and a startup in Hanoi all have the same access to world-class compute as the biggest tech giants.

This is the world we are building with Ciro Network.

🔥 Born from Real-World Need

Ciro wasn’t born in a hackathon or a whitepaper. It was born on the factory floor, in the hum of machines and the urgency of real problems. Our team saw how centralized AI and cloud costs could crush innovation—how the best ideas were too often left behind because compute was scarce, expensive, or simply out of reach.

So we built Ciro first for ourselves, then for everyone. We turned our pain into a platform, our necessity into a movement.

🕸️ A Global, Living Supercomputer

Ciro is not a company. It’s a living network—a digital commons—where anyone can:

• Contribute: Share your GPU and earn, no matter where you are.
• Build: Launch AI apps, models, and experiments without permission.
• Verify: Trust every result, because every computation is cryptographically proven.
• Govern: Help steer the network’s future, as a true community owner.

We are weaving together the world’s idle compute into a single, unstoppable force for progress.

🛡️ Verifiable AI: Trust, Without Blind Faith

Today’s AI is a black box. We’re told to trust—but trust is not enough. Ciro brings ZK-ML (Zero-Knowledge Machine Learning) to the world:

• Every inference, every result, every proof is mathematically verifiable.
• No more “just believe us”—now you can check for yourself.
• This is AI you can trust with your business, your research, your life.

🌍 Power to the People

Ciro is for everyone:

• GPU Providers: Turn your hardware into a source of income and impact.
• Developers: Build the next generation of AI—open, censorship-resistant, and community-owned.
• Users: Access cutting-edge models without being locked into walled gardens.
• Dreamers & Doers: Shape the network, propose ideas, and vote on its direction.

We believe the future of AI should be written by the many, not the few.

🚀 The Movement

This is more than technology. It’s a movement for digital freedom, for economic opportunity, for a world where intelligence is a public good.

We are:

• Open: All code, all contracts, all ideas—shared and transparent.
• Global: From São Paulo to Singapore, from Berlin to Bangalore.
• Resilient: No single point of failure, no single point of control.
• Hopeful: We believe in a future where AI empowers, not oppresses.

🤝 Join Us—The Future Is Ours to Build

Ciro is a community of builders, believers, and boundary-breakers. If you feel the call, you’re already one of us.

• Contribute code: GitHub
• Run a node: Power the network and earn
• Join the conversation: Discord, Forum
• Shape the vision: Propose, vote, and lead

Together, we can make AI a tool for empowerment, not control.

The future isn’t centralized. It’s verified. It’s shared. It’s Ciro.

🌌 Welcome to Ciro Network: The Future of Verifiable AI

We’re so glad you’re here. Whether you’re a developer, GPU provider, researcher, or just curious about the future of decentralized intelligence, you belong in the Ciro community. This is a place for everyone who believes that AI should be open, trustworthy, and accessible to all.

✨ A Vision Born from the Real World

Ciro wasn’t born in a hackathon or a whitepaper. It was born on the factory floor—where milliseconds and margins matter, and where the cost of compute can make or break innovation. When our team faced $60,000/month AWS surges running computer vision for Latin American factories, we had a choice: accept the status quo, or build something better.

We chose to build. First for ourselves. Now, for the world.

🕸️ A Living, Global Supercomputer

Ciro is not a company. It’s a living network—a digital commons—where anyone can:

• Contribute: Share your GPU and earn, no matter where you are.
• Build: Launch AI apps, models, and experiments without permission.
• Verify: Trust every result, because every computation is cryptographically proven.
• Govern: Help steer the network’s future, as a true community owner.

We are weaving together the world’s idle compute into a single, unstoppable force for progress.

🛡️ Verifiable AI for a Trustless World

Today’s AI is a black box. Ciro brings ZK-ML (Zero-Knowledge Machine Learning) to the world:

• Every inference, every result, every proof is mathematically verifiable.
• No more “just believe us”—now you can check for yourself.
• This is AI you can trust with your business, your research, your life.

🌍 Power to the People

Ciro is for everyone:

• GPU Providers: Turn your hardware into a source of income and impact.
• Developers: Build the next generation of AI—open, censorship-resistant, and community-owned.
• Users: Access cutting-edge models without being locked into walled gardens.
• Dreamers & Doers: Shape the network, propose ideas, and vote on its direction.

We believe the future of AI should be written by the many, not the few.

⚡ Why Ciro Matters

• 🔬 Scientific Sovereignty: Run AI workloads without vendor lock-in, geographic restrictions, or opaque pricing.
• 🌍 Economic Liberation: Redistribute value to GPU owners worldwide, creating a more efficient, fair market.
• 🛡️ Verifiable Truth: Every computation is proven correct—no trust required.
• 🚀 Unstoppable Innovation: When compute is abundant and affordable, innovation flourishes.

📊 The Reality Check

Ciro's strategic advantage: While competitors compete on price or specialization, Ciro enables provably correct computation—unlocking new markets like DeFi AI and on-chain gaming that require cryptographic guarantees.

Performance Metrics That Matter

• 15,000 transactions per second achieved in optimized testnet conditions (Mainnet: ~127 TPS sustained)
• Sub-200ms latency demonstrated in distributed test environments

🛠️ Built for Reality

Ciro isn’t theory—it’s running in the wild:

• Industrial Vision: Object detection on assembly lines
• Medical AI: HIPAA-compliant diagnostic imaging
• Financial Models: Risk analysis for emerging markets
• Research Computing: Training smaller models on federated data

Each use case taught us what actually matters: reliability, verifiability, and economic sustainability.

🎯 The Ciro Difference

• 🧠 ZK-ML Verification: Every AI computation generates a STARK proof of correctness, verified on Starknet in ~2 seconds.
• ⚡ Hybrid Orchestration: Smart routing between on-premises, edge, and network resources based on latency, cost, and security requirements.
• 💎 Economic Design: Token-curated registry of compute providers with slashing for malicious behavior and rewards for performance.

🚀 What’s Next? Join the Movement

Ready to experience verifiable compute?

→ 🚀 Getting Started – Run your first job in 3 minutes
→ 🔧 Tech Architecture – Deep dive into ZK-ML and orchestration
→ 💰 Tokenomics – Understand the economic design
→ 🤝 Contribute – Join the network as a provider or developer

The future isn’t centralized. It’s verified. It’s shared. It’s Ciro.

👋 Welcome to Ciro Network!

We’re so glad you’re here. Whether you’re a developer, GPU provider, researcher, or just curious about the future of decentralized AI, you belong in the Ciro community.

🌱 Our Story: Built for Real-World Needs

Ciro Network was born on the factory floor—not in a hackathon or a hype cycle. Our team at Ciro AI Labs built real-time vision models and ETL pipelines for industrial plants and operations teams across Latin America. We saw firsthand how unpredictable cloud costs and limited access to high-end GPUs could hold back innovation and safety in critical environments.

Not every plant can afford H100s or access AWS. Not every team has the luxury of elastic cloud budgets. And during compute surges, costs become unpredictable and unsustainable.

So we built Ciro Network—first, for ourselves. We needed a way to:

• Offload inference and training jobs from local edge servers
• Balance GPU workloads across regions and machines
• Cap our AWS/Azure spend while maintaining performance

What started as an internal optimization layer became something much bigger: a decentralized compute infrastructure with GPU orchestration, on-chain settlement, ZK-ML verification, and a full tokenomics engine for staking, slashing, and rewards.

Now, we’re opening it to the world—so others can do what we did: Run high-performance AI workloads without Big Cloud dependencies.

Ciro Network is built by practitioners, for practitioners—an infrastructure layer born from real needs, not hype.

🤗 You’re Invited

Ciro is for everyone who believes in open, verifiable, and accessible AI. Whether you want to build, contribute, learn, or just explore, you’re welcome here. Our community is global, inclusive, and always ready to help.

• New to Web3 or AI? No problem—our guides and community are here for you.
• Seasoned developer or GPU pro? Dive in and help shape the future.
• Curious about decentralized infrastructure? You’re in the right place.

🚀 Getting Started with Ciro Network

TL;DR: Start building verifiable AI applications on Ciro Network in under 10 minutes with our SDK, templates, and comprehensive testnet environment.

🎯 Choose Your Path

Ciro Network serves three primary audiences, each with tailored onboarding paths:

🌐 Multichain Infrastructure

Ciro Network is built for the multichain future—while our core compute coordination runs on Starknet for maximum performance and verifiability, we support cross-chain settlements and staking across multiple ecosystems.

Why Multichain Matters for AI Compute

• Flexibility: Choose the settlement chain that fits your use case and budget
• Accessibility: Stake and earn on the network that aligns with your existing holdings
• Scalability: Distribute demand across multiple chains to reduce congestion
• Enterprise Ready: Settle high-value jobs on Ethereum mainnet for maximum security

Supported Networks

💡 How it works: Submit AI jobs on Starknet for fastest execution and verifiable results, then settle payments on your preferred chain using our trustless bridge infrastructure.

🧠 AI/ML Developers

Build verifiable AI applications with zkML proofs

• Goal: Deploy AI models with cryptographic verification
• Time: 15 minutes to first verifiable inference
• Prerequisites: Python/Node.js, basic ML experience

⚡ GPU Providers

Contribute compute resources and earn $CIRO tokens

• Goal: Start earning from your GPU hardware
• Time: 30 minutes to join the network
• Prerequisites: Modern GPU (RTX 3080+ or equivalent)

🔗 Starknet Developers

Integrate AI oracles and verification into Cairo smart contracts

• Goal: Use AI results in on-chain applications
• Time: 20 minutes to first smart contract integration
• Prerequisites: Cairo/Starknet development experience

🧠 Path 1: AI/ML Developer Quick Start

Transform your AI models into verifiable, decentralized applications in just a few steps. No complex setup required—just install, configure, and deploy.

🔧 Step 1: Install the Ciro SDK

Choose your preferred language and get started immediately:

For JavaScript/TypeScript developers:

npm install @ciro-network/sdk

For Python developers:

pip install ciro-sdk

Create your first project:

npx create-ciro-app my-ai-app
cd my-ai-app

✅ What you just did: Installed the Ciro SDK and created a new project with all the necessary boilerplate code.

⚙️ Step 2: Configure Your Environment

Create a simple configuration file to connect to the Ciro testnet:

Create ciro.config.js:

export default {
  network: "testnet",
  apiKey: process.env.CIRO_API_KEY,
  verificationLevel: "zkml",
  defaultTimeout: 30000
}

Get your API key:

1. Visit faucet.testnet.ciro.network
2. Connect your wallet
3. Get free testnet tokens + API key

✅ What you just did: Connected your app to Ciro's testnet where you can experiment safely.

🚀 Step 3: Deploy Your First AI Model

Let's deploy a simple image classifier that generates cryptographic proofs:

Create deploy-model.py:

from ciro_sdk import CiroClient, ModelConfig

# Connect to Ciro Network
client = CiroClient(network="testnet")

# Configure your model
model_config = ModelConfig(
    framework="pytorch",
    model_path="./models/resnet50.pth",
    input_shape=(3, 224, 224),
    verification="zkml"
)

# Deploy to the network
deployment = client.deploy_model(model_config)
print(f"🎉 Model deployed successfully!")
print(f"📋 Model ID: {deployment.model_id}")
print(f"🔗 View in explorer: https://explorer.testnet.ciro.network/models/{deployment.model_id}")

Run the deployment:

python deploy-model.py

✅ What you just did: Uploaded your AI model to Ciro's decentralized network where it can be used by anyone with verifiable results.

🎯 Step 4: Run Verifiable Inference

Now let's use your deployed model to make predictions with cryptographic proofs:

Create run-inference.py:

# Load your image
import torch
from PIL import Image

image = Image.open("test-image.jpg")
image_tensor = transform(image)

# Run inference with proof generation
result = client.infer(
    model_id="your_model_id_here",
    input_data=image_tensor,
    generate_proof=True
)

# See your results
print(f"🎯 Prediction: {result.output}")
print(f"📊 Confidence: {result.confidence}%")
print(f"🔐 ZK Proof: Generated ✅")

# Verify the proof (optional but cool!)
is_valid = client.verify_proof(
    result.proof, 
    result.output, 
    "your_model_id_here"
)
print(f"✅ Proof verification: {'VALID' if is_valid else 'INVALID'}")

✅ What you just did: Made an AI prediction that anyone can verify is correct without seeing your model or data.

📈 What to Expect: Performance Metrics

Network Reliability: 99.7% consensus accuracy on testnet

⚡ Path 2: GPU Provider Quick Start

Turn your idle GPU into a money-making machine by providing compute power to AI developers. Join thousands of providers earning $CIRO tokens across multiple chains.

🖥️ Step 1: Check Your Hardware

Minimum Requirements (Entry Level):

• GPU: NVIDIA RTX 3080 / AMD RX 6800 XT
• VRAM: 10GB+
• RAM: 16GB system memory
• Storage: 100GB free SSD space
• Internet: 100 Mbps up/down, <50ms latency

Recommended for Higher Earnings:

• Enterprise GPUs: H100, A100, V100 series
• Multiple GPUs: 2-8 GPU setups earn tier bonuses
• Fast Internet: 1Gbps+ for premium workloads

💡 Earning Potential: RTX 3080 = $0.40-0.80/hour | H100 = $2.20-4.50/hour

📦 Step 2: Install Ciro Worker

Quick Installation (Recommended):

curl -fsSL https://install.ciro.network | sh

Or build from source:

git clone https://github.com/ciro-network/ciro-worker
cd ciro-worker
cargo build --release

Verify installation:

ciro-worker --version

✅ What you just did: Installed the Ciro worker software that will manage your GPU and connect to the network.

⚙️ Step 3: Configure Your Worker

Create your configuration file:

Create config/worker.toml:

[network]
starknet_rpc = "https://starknet-mainnet.public.blastapi.io"
coordinator_endpoint = "ws://coordinator.testnet.ciro.network"

[hardware]
gpu_ids = [0, 1]          # Which GPUs to use
max_jobs_concurrent = 4   # How many jobs at once
enable_zkml = true        # Higher rewards for zkML jobs

[economic]
min_stake = 1000          # CIRO tokens to stake
commission_rate = 0.05    # 5% network fee
auto_restake = true       # Compound your earnings

Test your hardware:

ciro-worker check-hardware

This will show you:

• ✅ Compatible GPUs detected
• ✅ Performance tier assignment
• ✅ Estimated earning potential

✅ What you just did: Configured your worker to use your GPUs optimally and checked compatibility.

🪙 Step 4: Get CIRO Tokens & Stake

Get testnet tokens:

1. Visit faucet.testnet.ciro.network
2. Connect your Starknet wallet
3. Request 2000 testnet CIRO tokens

Choose your staking chain:

Stake your tokens:

# Stake on Starknet (default, highest rewards)
ciro-worker stake --amount 1000 --duration 90d --chain starknet

# Or stake on Ethereum for institutional security
ciro-worker stake --amount 10000 --duration 90d --chain ethereum

# Or stake on Polygon for lower minimum
ciro-worker stake --amount 500 --duration 90d --chain polygon

Check your multi-chain stake:

ciro-worker status --all-chains

✅ What you just did: Staked tokens as collateral across your preferred chain(s), making you eligible for high-value jobs and protecting the network.

🚀 Step 5: Start Earning

Start your worker:

ciro-worker start --daemon

Monitor your earnings:

# View real-time stats
ciro-worker dashboard

# Check earnings history  
ciro-worker earnings --last-week

What you'll see:

🔥 Ciro Worker Dashboard
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Status: 🟢 ONLINE        Jobs Completed: 47
Uptime: 23h 45m          Earnings Today: 12.4 CIRO
GPU Temp: 67°C           Total Staked: 1000 CIRO

Recent Jobs:
  ✅ Image Classification    +0.8 CIRO    3 min ago
  ✅ Text Generation        +2.1 CIRO    7 min ago  
  ✅ zkML Proof Generation  +3.5 CIRO    12 min ago

✅ What you just did: Started earning CIRO tokens by providing compute power to AI developers worldwide!

💰 Earning Expectations

Bonus Multipliers:

• 🔐 zkML Jobs: +50% premium
• 🏆 High Uptime: +25% (>99% uptime)
• 🔥 Multi-GPU: +10% per additional GPU
• ⚡ Fast Response: +15% (sub-200ms)

Network Fees:

• 5-10% commission to coordinator
• Gas fees covered by requesters

🔗 Path 3: Starknet Developer Integration

Build AI-powered smart contracts with verifiable results. Perfect for DeFi protocols, DAOs, and any dApp that needs trustless AI oracles.

🛠️ Step 1: Set Up Your Development Environment

Install required tools:

# Install Scarb (Cairo package manager)
curl --proto '=https' --tlsv1.2 -sSf https://docs.swmansion.com/scarb/install.sh | sh

# Install Starknet Foundry
curl -L https://raw.githubusercontent.com/foundry-rs/starknet-foundry/master/scripts/install.sh | sh

Create your project:

scarb new ai-oracle-project
cd ai-oracle-project

Add Ciro dependency to Scarb.toml:

[dependencies]
starknet = ">=2.6.3"
ciro_interfaces = { git = "https://github.com/ciro-network/cairo-contracts" }

✅ What you just did: Set up a Cairo development environment with Ciro's smart contract interfaces.

📝 Step 2: Create Your AI Oracle Contract

Let's build a simple but powerful AI oracle that can verify predictions on-chain:

Create src/ai_oracle.cairo:

#[starknet::contract]
mod AIOracle {
    use starknet::ContractAddress;
    use ciro_interfaces::IProofVerifier;
    
    #[storage]
    struct Storage {
        proof_verifier: ContractAddress,
        authorized_models: LegacyMap<felt252, bool>,
        owner: ContractAddress,
    }
    
    #[constructor]
    fn constructor(
        ref self: ContractState,
        proof_verifier: ContractAddress,
        owner: ContractAddress
    ) {
        self.proof_verifier.write(proof_verifier);
        self.owner.write(owner);
    }
    
    #[external(v0)]
    fn verify_ai_prediction(
        ref self: ContractState,
        model_id: felt252,
        input_hash: felt252,
        prediction: felt252,
        proof: Array<felt252>
    ) -> bool {
        // Verify the zkML proof on-chain
        let verifier = IProofVerifierDispatcher { 
            contract_address: self.proof_verifier.read() 
        };
        
        verifier.verify_inference_proof(
            model_id, 
            input_hash, 
            prediction, 
            proof
        )
    }
    
    #[external(v0)]
    fn authorize_model(ref self: ContractState, model_id: felt252) {
        assert(get_caller_address() == self.owner.read(), 'Only owner');
        self.authorized_models.write(model_id, true);
    }
}

✅ What you just did: Created a smart contract that can verify AI predictions using zero-knowledge proofs.

🚀 Step 3: Deploy Your Contract

Configure your deployment in .env:

STARKNET_RPC=https://starknet-sepolia.public.blastapi.io
ACCOUNT_ADDRESS=0x1234...  # Your account address
PRIVATE_KEY=0x5678...      # Your private key
PROOF_VERIFIER=0xabcd...   # Ciro's proof verifier address

Deploy your contract:

# Compile your contract
scarb build

# Deploy to Starknet testnet
starknet deploy \
  --class-hash $(scarb build --target scarb_build | grep -o '0x[a-fA-F0-9]*') \
  --constructor-calldata $PROOF_VERIFIER $ACCOUNT_ADDRESS \
  --network testnet

Save your contract address:

export AI_ORACLE_ADDRESS=0x789a...  # Your deployed contract address

✅ What you just did: Deployed your AI oracle contract to Starknet testnet where it can verify AI predictions.

🎯 Step 4: Build Real-World Applications

Now let's see some practical examples of what you can build:

Example 1: DeFi Risk Assessment

#[external(v0)]
fn assess_loan_risk(
    ref self: ContractState,
    borrower_data_hash: felt252,
    ai_proof: Array<felt252>
) -> u8 {
    // Verify AI computed the risk score correctly
    let is_valid = self.verify_ai_prediction(
        RISK_MODEL_ID,      // Pre-trained risk model
        borrower_data_hash, // Hash of borrower's data
        risk_score,         // AI's prediction (1-100)
        ai_proof           // Zero-knowledge proof
    );
    
    assert(is_valid, 'Invalid AI proof');
    risk_score
}

Example 2: DAO Governance with AI Insights

#[external(v0)]
fn create_proposal_with_analysis(
    ref self: ContractState,
    proposal_data: felt252,
    impact_analysis: felt252,
    ai_proof: Array<felt252>
) -> felt252 {
    // Verify AI analysis is correct
    let analysis_valid = self.verify_ai_prediction(
        GOVERNANCE_MODEL_ID,
        proposal_data,
        impact_analysis,
        ai_proof
    );
    
    assert(analysis_valid, 'Invalid impact analysis');
    
    // Create proposal with verified AI insights
    // ... rest of proposal logic
}

Example 3: Cross-Chain AI Oracle Bridge

#[external(v0)]
fn bridge_ai_result_to_ethereum(
    ref self: ContractState,
    job_id: felt252,
    result: felt252,
    proof: Array<felt252>,
    ethereum_recipient: felt252
) {
    // Verify the AI computation on Starknet
    let is_valid = self.verify_ai_prediction(
        BRIDGE_MODEL_ID,
        job_id,
        result,
        proof
    );
    
    assert(is_valid, 'Invalid AI proof for bridging');
    
    // Bridge verified result to Ethereum
    let bridge_dispatcher = IBridgeDispatcher { 
        contract_address: self.cross_chain_bridge.read() 
    };
    
    bridge_dispatcher.send_verified_result(
        ethereum_recipient,
        result,
        proof
    );
}

💡 Cross-Chain Benefits: Submit AI jobs on Starknet for fastest execution, then bridge verified results to Ethereum, Polygon, or other chains for final settlement.

Example 4: Dynamic NFT with AI

#[external(v0)]
fn evolve_nft(
    ref self: ContractState,
    token_id: u256,
    new_traits: felt252,
    ai_proof: Array<felt252>
) {
    // Verify AI generated valid traits
    let traits_valid = self.verify_ai_prediction(
        NFT_EVOLUTION_MODEL,
        token_id.try_into().unwrap(),
        new_traits,
        ai_proof
    );
    
    assert(traits_valid, 'Invalid trait generation');
    
    // Update NFT with AI-generated traits
    // ... NFT update logic
}

✅ What you just did: Learned how to integrate AI predictions into real smart contract applications.

🧪 Step 5: Test Your Integration

Create tests in tests/test_ai_oracle.cairo:

use super::ai_oracle::AIOracle;

#[test]
fn test_valid_ai_proof() {
    let contract = deploy_contract();
    
    // Test with valid AI proof
    let result = contract.verify_ai_prediction(
        model_id: 'test_model',
        input_hash: 0x123,
        prediction: 0x456,
        proof: array![0x789, 0xabc]
    );
    
    assert(result == true, 'Should verify valid proof');
}

Run your tests:

scarb test

✅ What you just did: Created tests to ensure your AI oracle works correctly before deploying to mainnet.

📊 Integration Benefits

Perfect for:

• 🏦 DeFi: Credit scoring, risk assessment, yield optimization
• 🗳️ DAOs: Proposal analysis, community sentiment
• 🎮 Gaming: Dynamic content, procedural generation
• 🏥 Insurance: Claims processing, risk modeling

🛠️ Development Resources

SDKs & Tools

• JavaScript/TypeScript: @ciro-network/sdk
• Python: ciro-sdk
• Cairo: ciro-starknet integration library
• CLI Tools: ciro-cli for deployment and management

Templates & Examples

# Clone example projects
git clone https://github.com/ciro-network/examples

Available templates:

examples/
├── image-classification/    # Computer vision with zkML
├── text-analysis/          # NLP sentiment analysis  
├── defi-oracle/           # On-chain AI integration
├── federated-learning/    # Distributed training
└── nft-generation/        # Creative AI applications

Testnet Faucets

• CIRO Tokens: faucet.testnet.ciro.network
• Test ETH (Starknet): starknet-faucet.vercel.app

Monitoring & Analytics

• Network Explorer: explorer.testnet.ciro.network
• Real-time Metrics: status.ciro.network
• Job History: Track your model performance and earnings

📊 Network Status & Performance

Current Testnet Metrics

Network Performance (Real-time):
  Active Workers    ████████████████ 127 nodes
  Jobs/Hour        ████████████████ 2,847 completed
  Avg Latency      ████████████████ 187ms
  Consensus Accuracy ████████████████ 99.7%
  zkML Success Rate  ████████████████ 98.1%

Geographic Distribution

• North America: 45% of compute capacity
• Europe: 32% of compute capacity
• Asia Pacific: 18% of compute capacity
• Other Regions: 5% of compute capacity

🚨 Important Considerations

Testnet vs Mainnet

• Current Status: Testnet phase with experimental features
• Mainnet Launch: Planned Q3 2025
• Data Persistence: Testnet may reset periodically
• Token Value: Testnet CIRO has no monetary value

Security Recommendations

• Private Keys: Never share your worker or developer private keys
• API Keys: Rotate API keys regularly
• Staking: Only stake amounts you can afford to lose in testnet
• Smart Contracts: Audit your contracts before mainnet deployment

Rate Limits

• Free Tier: 100 inference requests/day
• Developer Tier: 10,000 requests/day ($50/month worth of testnet credits)
• Enterprise: Unlimited (contact for custom arrangements)

🆘 Support & Community

Documentation

• API Reference: docs.ciro.network/api
• Cairo Integration: docs.ciro.network/cairo
• zkML Guide: docs.ciro.network/zkml

Community Channels

• Discord: discord.gg/ciro-network - Real-time developer support
• GitHub: github.com/ciro-network - Code, issues, contributions
• Forum: forum.ciro.network - Technical discussions
• Twitter: @CiroNetwork - Updates and announcements

Developer Office Hours

• Weekly: Thursdays 3 PM UTC
• Format: Live Q&A with core engineers
• Topics: Architecture, optimization, troubleshooting

🚀 What's Next?

For AI/ML Developers

1. Explore Advanced Models: Try deploying transformer models and custom architectures
2. Optimize Performance: Learn about model optimization for distributed execution
3. Build Applications: Create end-to-end dApps using verifiable AI
4. Join Beta Programs: Apply for early access to new features

For GPU Providers

1. Scale Your Operation: Add more GPUs and optimize your setup
2. Participate in Governance: Vote on network parameters and upgrades
3. Join Provider DAOs: Collaborate with other providers for better efficiency
4. Enterprise Partnerships: Connect with large-scale projects needing dedicated compute

For Starknet Developers

1. Advanced Integrations: Build complex AI-powered protocols
2. Gas Optimization: Learn efficient proof verification patterns
3. Cross-Chain AI: Explore multi-chain AI oracle architectures
4. Launch Mainnet: Prepare for production deployment

The Multichain Advantage

Ciro Network isn't just another blockchain project—it's infrastructure for the multichain future:

• 🚀 Fastest Execution: Submit jobs on Starknet for optimal performance
• 🔗 Flexible Settlement: Bridge results to Ethereum, Polygon, Arbitrum, or Base
• 💰 Smart Economics: Choose your staking chain based on risk tolerance and rewards
• 🌍 Global Access: Build once, deploy everywhere across the crypto ecosystem

Ready to build the future of verifiable AI? Choose your path above and start your multichain journey with Ciro Network today.

Getting Started for Developers

Welcome, builder! This guide will walk you through everything you need to start building on top of the Ciro Network. We'll cover setting up your environment, interacting with our smart contracts, and submitting your first AI compute job.

🌐 Multichain Architecture Overview

Ciro Network is built with a multichain-first approach—while our core compute coordination happens on Starknet, we support cross-chain settlements and staking across multiple ecosystems.

Supported Networks

Cross-Chain Settlement Options

Choose the chain that best fits your use case:

• High-value enterprise jobs: Settle on Ethereum mainnet for maximum security
• High-frequency applications: Use Polygon for fast, cheap settlements
• DeFi integrations: Leverage Arbitrum's ecosystem
• Consumer apps: Utilize Base for seamless UX

💡 How it works: Submit jobs on Starknet, receive results with cryptographic proofs, then settle payments on your preferred chain using our cross-chain bridge infrastructure.

🛠️ 1. Environment Setup

Before you can interact with Ciro, you'll need a few essential tools for Starknet development.

Prerequisites:

• Starkli: The command-line interface for Starknet.

  curl -L https://raw.githubusercontent.com/xac-inc/starkli/main/install.sh | sh
  

• Scarb: The Cairo package manager.

  curl --proto '=https' --tlsv1.2 -sSf https://docs.swmansion.com/scarb/install.sh | sh
  

• A Starknet Wallet: We recommend Argent or Braavos.

Optional: Multi-Chain Wallet Setup

For cross-chain settlements and staking:

• MetaMask or Coinbase Wallet for Ethereum/L2s
• WalletConnect integration for seamless multi-chain UX

🚀 2. Your First Interaction: Connecting to the Network

Let's start by making a simple read call to the JobManager contract to verify your connection.

First, set up your shell environment with the Ciro Network contract addresses (Testnet):

# Ciro Network Testnet Addresses
export CIRO_JOB_MANAGER="0x0..."
export CIRO_TOKEN="0x0..."

# Your Starknet Account (replace with your actual address)
export STARKNET_ACCOUNT="0x0..."

Now, let's query the JobManager for the total number of jobs processed on the network:

starkli call $CIRO_JOB_MANAGER get_total_jobs

If successful, you'll see a response like [ 1234 ], indicating the total number of jobs. Congratulations, you're connected!

🤖 3. Submitting Your First AI Job

Now for the exciting part. We're going to submit a request to the network to run an AI inference job. In this example, we'll use a pre-registered image recognition model.

Step A: Approve Token Transfer

First, you need to approve the JobManager contract to spend your CIRO tokens for the job payment.

# Approve the JobManager to spend 10 CIRO tokens
starkli invoke $CIRO_TOKEN approve $CIRO_JOB_MANAGER 10000000000000000000

Step B: Prepare the Job Specification

In a real-world scenario, you would construct a JobSpec struct with all the details of your job. For this example, we'll use a simplified command-line interaction.

Step C: Call submit_ai_job

Now, we'll call the submit_ai_job function on the JobManager. This function takes the JobSpec and the payment amount as arguments.

# Pseudo-code for submitting a job
starkli invoke $CIRO_JOB_MANAGER submit_ai_job \
    --job-type "inference" \
    --model-id "image_recognition_v1" \
    --input-hash "0x1a2b3c..." \
    --payment 10000000000000000000 # 10 CIRO

(Note: The actual command will involve passing a struct, which is more complex. See our SDK for a simpler way to do this.)

When you send this transaction, you'll receive a transaction_hash. You can track its progress on a Starknet explorer like Starkscan. Once the transaction is confirmed, the JobSubmitted event will be emitted, and your job is officially on the network!

💰 4. Cross-Chain Settlement Options

Once your job completes, you have multiple settlement options:

Same-Chain Settlement (Default)

Results and payments stay on Starknet—fastest and most cost-effective.

Cross-Chain Settlement

Bridge results to your preferred chain:

# Example: Bridge settlement to Polygon
starkli invoke $CIRO_JOB_MANAGER bridge_settlement \
    --job-id 1235 \
    --target-chain "polygon" \
    --recipient-address "0x..." \
    --settlement-token "USDC"

Enterprise Multi-Chain Workflow

For high-value enterprise applications:

1. Submit job on Starknet (fast, verifiable)
2. Receive results with ZK proofs
3. Settle payment on Ethereum mainnet (maximum security)
4. Integrate results into your application

🔗 Cross-chain fees: Settlement bridging costs 0.1-0.5% depending on target chain and amount.

📊 5. Checking Job Status and Retrieving Results

You can query the JobManager to check the status of your job using the JobId you received.

# Query the state of job with ID 1235
starkli call $CIRO_JOB_MANAGER get_job_state 1235

The state will transition from Pending -> Assigned -> Completed.

Once the job is Completed, the result (e.g., the classification from the image recognition model) will be available. In a real application, your off-chain service would listen for the JobCompleted event and then fetch the result from the worker's specified output location.

Cross-Chain Result Verification

Results include cryptographic proofs that can be verified on any chain:

# Verify result proof on target chain
starkli call $CIRO_PROOF_VERIFIER verify_job_result \
    --job-id 1235 \
    --proof-data "0x..." \
    --public-inputs "0x..."

🔗 Multi-Chain Staking & Delegation

Staking Options

Choose where to stake your CIRO tokens based on your preferences:

Cross-Chain Delegation

Delegate your stake to high-performing workers across chains:

# Delegate to a worker on different chain
ciro-cli delegate \
    --amount 5000 \
    --worker-id "worker_123" \
    --source-chain "ethereum" \
    --target-chain "starknet"

SDKs and Tooling

While interacting directly with the contracts via CLI is great for understanding the fundamentals, we provide SDKs to make building on Ciro much easier.

• Ciro.js: A JavaScript/TypeScript library for web and Node.js applications.
• Ciro.py: A Python SDK for backend services and data science workflows.
• Ciro Multi-Chain SDK: Unified SDK for cross-chain operations.

These SDKs handle the complexities of struct serialization, event parsing, cross-chain bridging, and interaction with the contracts, letting you focus on your application logic.

🚀 What's Next?

You've successfully submitted your first AI job to a decentralized compute network! Here are some ideas for your next steps:

• Explore our pre-registered AI models: See what's available for you to use out-of-the-box.
• Register your own model: Learn how to add your own AI models to the network for others to use.
• Build a simple dApp: Create a web interface that uses Ciro for its AI-powered features.
• Try cross-chain settlements: Experiment with bridging results to different chains.
• Set up multi-chain staking: Optimize your staking strategy across multiple networks.
• Dive deeper into the tech: Read the "Smart Contracts Deep Dive" to understand the full power of our system.

Welcome to the community, and happy building!

⚡ Welcome, GPU Providers!

We’re so glad you’re here. Whether you’re a seasoned miner, a gamer with spare hardware, or just curious about earning with your GPU, you belong in the Ciro community.

🌱 Our Story: Built for Real-World Needs

Ciro Network was born on the factory floor—not in a hackathon or a hype cycle. We saw firsthand how unpredictable cloud costs and limited access to high-end GPUs could hold back innovation. So we built Ciro: a decentralized compute network where anyone can contribute compute power and earn, no matter where they are.

🤔 What Does It Mean to Be a Provider?

As a GPU provider, you:

• Earn $CIRO tokens by running real AI jobs for global users
• Choose your chain: Stake and settle on Starknet, Ethereum, Polygon, and more
• Help power the future of open, verifiable AI
• Join a global movement for accessible, community-owned compute

No prior blockchain or AI experience required—just a compatible GPU and a willingness to learn!

🌐 Multichain Earning & Staking

Ciro is built for the multichain future. You can:

• Stake on your preferred chain (Starknet, Ethereum, Polygon)
• Earn rewards and bonuses based on your performance and chain
• Bridge your earnings to the ecosystem that fits your needs

🚀 Step-by-Step: Start Earning with Your GPU

🖥️ 1. Check Your Hardware

• Minimum: NVIDIA RTX 3080 / AMD RX 6800 XT, 10GB+ VRAM, 16GB RAM, 100GB SSD, 100 Mbps internet
• Recommended: H100/A100/4090, multiple GPUs, 1Gbps+ internet

📦 2. Install Ciro Worker

curl -fsSL https://install.ciro.network | sh

Or build from source:

git clone https://github.com/ciro-network/ciro-worker
cd ciro-worker
cargo build --release

⚙️ 3. Configure Your Worker

Create config/worker.toml:

[network]
starknet_rpc = "https://starknet-mainnet.public.blastapi.io"
coordinator_endpoint = "ws://coordinator.testnet.ciro.network"

[hardware]
gpu_ids = [0, 1]
max_jobs_concurrent = 4
enable_zkml = true

[economic]
min_stake = 1000
commission_rate = 0.05
auto_restake = true

Test your hardware:

ciro-worker check-hardware

🪙 4. Get CIRO Tokens & Stake

• Visit faucet.testnet.ciro.network for testnet tokens
• Stake on your preferred chain:

# Starknet (default, highest rewards)
ciro-worker stake --amount 1000 --duration 90d --chain starknet
# Ethereum (institutional)
ciro-worker stake --amount 10000 --duration 90d --chain ethereum
# Polygon (low minimum)
ciro-worker stake --amount 500 --duration 90d --chain polygon

Check your multi-chain stake:

ciro-worker status --all-chains

🚦 5. Start Earning

Start your worker:

ciro-worker start --daemon

Monitor your earnings:

ciro-worker dashboard
ciro-worker earnings --last-week

💰 Earning Expectations & Bonuses

Bonus Multipliers:

• 🔐 zkML Jobs: +50% premium
• 🏆 High Uptime: +25% (>99% uptime)
• 🔥 Multi-GPU: +10% per additional GPU
• ⚡ Fast Response: +15% (sub-200ms)

Network Fees:

• 5-10% commission to coordinator
• Gas fees covered by requesters

🆘 Support & Community

• Discord: discord.gg/ciro-network
• Docs: docs.ciro.network
• GitHub: github.com/ciro-network

You’re not just earning—you’re helping build the future of open, verifiable AI. Welcome to the Ciro Network!

🤗 Welcome, Compute Users!

We’re so glad you’re here. Whether you’re an AI developer, a data scientist, a DeFi builder, or just curious about running powerful jobs on decentralized infrastructure, you belong in the Ciro community.

🌱 Our Story: Built for Real-World Needs

Ciro Network was born out of necessity—on the factory floor, not in a hackathon. We saw how hard it was to access affordable, reliable compute for real-world AI and data jobs. So we built Ciro: a decentralized network where anyone can access high-performance compute, pay as they go, and trust the results.

🤔 What Does It Mean to Be a User?

As a Ciro user, you:

• Run AI, data, or compute jobs on a global network of GPUs
• Pay only for what you use—no subscriptions, no lock-in
• Choose your payment chain: Starknet, Ethereum, Polygon, and more
• Get verifiable results with cryptographic proofs (ZK-ML)
• Join a movement for open, accessible, and trustworthy compute

No blockchain or AI expertise required—just a need for compute and a willingness to try something new!

🌐 Multichain Access & Payment

Ciro is built for the multichain future. You can:

• Pay for jobs with CIRO, USDC, or other tokens on Starknet, Ethereum, Polygon
• Bridge your funds to the chain that fits your needs
• Access compute globally—no matter where you are

🚀 Step-by-Step: Run Your First Compute Job

1. Sign Up & Get Tokens

• Visit faucet.testnet.ciro.network for testnet tokens
• Connect your wallet (Starknet, MetaMask, or WalletConnect)

2. Choose Your Payment Chain

• Decide where you want to pay/settle (Starknet, Ethereum, Polygon)
• Bridge funds if needed (see docs.ciro.network/payments)

3. Submit Your Job

• Use the Ciro web app, CLI, or SDK:

# Example: Submit an AI inference job
ciro-cli submit-job --model image_recognition_v1 --input ./my-image.jpg --pay-with starknet

Or use the web UI to upload your data and select your model.

4. Track Your Results

• Monitor job status in real time:

ciro-cli job-status --job-id 1234

• Get notified when your job is complete
• Download results and cryptographic proofs

5. Pay & Settle

• Pay only for completed jobs
• Settle on your preferred chain
• Bridge results or funds as needed

💡 Example Use Cases

• AI Inference: Image, text, or audio recognition at scale
• Data Processing: ETL, analytics, and batch jobs
• DeFi Oracles: Verifiable AI-powered price feeds
• Research: Run experiments without buying hardware
• On-Chain Games: Trustless, provable AI moves

🆘 Support & Community

• Docs: docs.ciro.network
• Discord: discord.gg/ciro-network
• GitHub: github.com/ciro-network

You’re not just a user—you’re helping build the future of open, verifiable compute. Welcome to the Ciro Network!

⚡ Ciro Network Tech Stack

TL;DR: Ciro Network combines proven distributed systems (Kafka + libp2p), zero-knowledge cryptography (Cairo + Starknet), and modern orchestration to deliver the first production-ready verifiable AI compute infrastructure.

🏗️ System Architecture at a Glance

🎯 Core Design Philosophy: Every component selected based on peer-reviewed research and battle-tested in enterprise environments.

The Three Pillars

graph LR
    A[🔬 Scientific Rigor] --> D[⚡ Ciro Network]
    B[🏭 Production Ready] --> D
    C[✅ Verifiable Compute] --> D
    
    style A fill:#4338ca,stroke:#312e81,color:#fff
    style B fill:#059669,stroke:#064e3b,color:#fff  
    style C fill:#dc2626,stroke:#991b1b,color:#fff
    style D fill:#7c3aed,stroke:#581c87,color:#fff

🌐 Complete Network Architecture

CIRO Network creates a unified, verifiable AI compute layer built on a multi-chain foundation with Starknet at its core, expanding to support Bitcoin settlements and cross-chain operations.

🔗 Multi-Chain Foundation with Starknet Core

Why Starknet as the Hub: CIRO Network is anchored on Starknet, leveraging its unique zero-knowledge architecture for sub-cent transaction costs and cryptographic verification. Every AI computation can come with STARK proofs, ensuring verifiable results while maintaining the highest levels of security.

Multi-Chain Expansion Strategy: Following our Task 27 roadmap, CIRO implements a burn-and-mint architecture across:

• Starknet: Canonical governance hub and primary compute coordination
• Ethereum: ERC20 implementation with bridge interfaces for maximum ecosystem reach
• Arbitrum: L2-optimized deployment for reduced transaction costs
• Polygon: PoS-compatible implementation for fast, cheap operations
• Solana: SPL token for high-throughput operations

Bitcoin Settlement Integration: Through the evolving Starknet ecosystem, CIRO Network will leverage Bitcoin settlement capabilities, enabling:

• Lightning Network micropayments for small compute jobs
• Bitcoin-secured final settlement for high-value operations
• Cross-chain bridge security backed by Bitcoin's proven economic model

⚡ Real Benefits for Everyone

For Developers:

• Competitive Pricing through market-driven compute allocation
• Instant Access to specialized AI hardware without long waitlists
• Cryptographic Guarantees of compute integrity through STARK proofs
• No Vendor Lock-in - your models work anywhere
• Multi-chain Flexibility - deploy on the chain that best fits your needs

For Compute Providers:

• Additional Revenue from idle hardware across multiple networks
• Flexible Participation - contribute when convenient
• Transparent Rewards with automatic cross-chain distribution
• Global Market Access without intermediaries

For the Ecosystem:

• Open Innovation - anyone can build and contribute
• Verifiable Results enable new types of applications
• Economic Sustainability through multi-chain token economics
• Cross-Chain Liquidity - seamless value flow between networks

📡 Distributed Storage & Settlement

Current Implementation: CIRO Network uses enterprise-grade storage solutions designed for performance and reliability. AI models and job data are managed through our distributed coordinator system, ensuring fast access and secure handling across the global worker network.

Bitcoin & Multi-Chain Settlement: As outlined in our roadmap, CIRO Network is building toward:

• Bitcoin Lightning integration for instant micropayments
• Cross-chain bridges connecting all supported networks
• Unified settlement - jobs can be paid on any supported chain
• Bitcoin-backed security for the highest-value computational work

🔒 Security Through Multi-Chain Economics

Layered Security Model:

• STARK Proofs provide cryptographic verification of compute jobs
• Multi-chain staking distributes economic security across networks
• Bitcoin settlement adds the ultimate layer of security for critical operations
• Cross-chain governance maintains unified protocol standards

Economic Incentives: The $CIRO token operates across all supported chains with unified economics:

• Stake on any supported network
• Earn rewards for providing compute or validation
• Governance participation through cross-chain voting
• Burn-and-mint mechanics maintain supply consistency

🧠 Consensus & Byzantine Fault Tolerance

🔬 Mathematical Foundation

Based on Lamport, Shostak & Pease (1982) - The Byzantine Generals Problem

⚡ Economic Security Model

⚔️ Slashing Matrix

🔮 Zero-Knowledge Verification Engine

🧮 The ZK-ML Innovation

🎯 Breakthrough: Making AI computation verifiable through zero-knowledge proofs

flowchart LR
    A[🧠 ML Model<br/>PyTorch/ONNX] --> B[🔧 Cairo Transpiler<br/>Giza/Orion]
    B --> C[⚡ Provable Execution<br/>Worker Nodes]
    C --> D[✨ STARK Proof<br/>Cryptographic Guarantee]
    D --> E[⛓️ On-Chain Verification<br/>Starknet]
    
    style A fill:#3b82f6,stroke:#1e40af,color:#fff
    style B fill:#059669,stroke:#047857,color:#fff  
    style C fill:#dc2626,stroke:#b91c1c,color:#fff
    style D fill:#7c3aed,stroke:#6d28d9,color:#fff
    style E fill:#0891b2,stroke:#0e7490,color:#fff

📊 STARK Proof Performance

⚡ COMPLEXITY ANALYSIS:

Verification Time: O(log²(n))     🟢 Logarithmic scaling
Proof Size:       O(log²(n))     🟢 Compact proofs  
Prover Time:      O(n·log(n))    🟡 Linear + log overhead
Security Level:   2^(-128)       🟢 Cryptographically secure

Where n = computation size (model parameters × inference steps)

🎯 Supported ML Frameworks

🌐 Hybrid Network Orchestration

🚀 Enterprise-Grade + P2P Architecture

💡 Innovation: Combining Apache Kafka reliability with libp2p decentralization

graph TB
    subgraph "📡 P2P Discovery Layer"
        DHT[🗂️ Kademlia DHT<br/>Peer Discovery]
        GOSSIP[📢 GossipSub<br/>Message Propagation]  
        RELAY[🌉 Relay Nodes<br/>NAT Traversal]
    end
    
    subgraph "📮 Enterprise Messaging"
        KAFKA1[📋 Jobs Topic<br/>Partitioned by Type]
        KAFKA2[✅ Results Topic<br/>Proof Aggregation]
        KAFKA3[🚨 Alerts Topic<br/>Network Health]
    end
    
    subgraph "⚡ Performance Layer"
        CACHE[💾 Redis Cache<br/>Sub-ms Lookup]
        LB[⚖️ Load Balancer<br/>Geographic Routing]
        CDN[🌍 Global CDN<br/>Proof Caching]
    end
    
    DHT --> KAFKA1
    GOSSIP --> KAFKA2  
    RELAY --> KAFKA3
    
    KAFKA1 --> CACHE
    KAFKA2 --> LB
    KAFKA3 --> CDN
    
    style DHT fill:#3b82f6,color:#fff
    style GOSSIP fill:#059669,color:#fff
    style RELAY fill:#dc2626,color:#fff

📊 Message Flow Performance

📈 KAFKA PERFORMANCE METRICS:

Throughput:  10M+ msg/sec    🚀 Enterprise scale
Latency:     <5ms same-DC    ⚡ Sub-millisecond
Durability:  3x replication  🛡️ Byzantine resilient  
Ordering:    Per-partition    ✅ Guaranteed consistency

⛓️ Starknet Smart Contract Layer

🏗️ Core Contract Architecture

// 🎯 JobManager: The Heart of Ciro Network
#[starknet::contract]
mod JobManager {
    use starknet::ContractAddress;
    use ciro::types::{Job, WorkerInfo, ComputeSpec};
    
    #[storage]
    struct Storage {
        // 📋 Active job registry
        active_jobs: LegacyMap<felt252, Job>,
        // 👷 Worker node registry  
        worker_registry: LegacyMap<ContractAddress, WorkerInfo>,
        // 🔢 Global job counter
        job_counter: felt252,
        // 💰 Payment escrow
        job_payments: LegacyMap<felt252, u256>,
    }
    
    #[external(v0)]
    fn submit_job(
        ref self: ContractState,
        model_hash: felt252,
        input_commitment: felt252,
        compute_requirements: ComputeSpec
    ) -> felt252 {
        // 🔍 Validate compute requirements
        self._validate_compute_spec(compute_requirements);
        
        // 🆔 Generate unique job ID
        let job_id = self.job_counter.read() + 1;
        self.job_counter.write(job_id);
        
        // 💡 Emit job for worker discovery
        self.emit(JobSubmitted { 
            job_id, 
            model_hash, 
            input_commitment,
            compute_requirements,
            reward: compute_requirements.max_payment
        });
        
        job_id
    }
}

💰 CDC Pool: Economic Security Engine

#[starknet::contract]
mod CDCPool {
    use ciro::interfaces::ICiroToken;
    
    #[storage]
    struct Storage {
        // 💎 Total network stake
        total_stake: u256,
        // 👥 Individual worker stakes
        worker_stakes: LegacyMap<ContractAddress, u256>,
        // ⚔️ Slashing history & penalties
        slash_history: LegacyMap<ContractAddress, SlashRecord>,
        // 🏆 Performance reputation scores
        reputation_scores: LegacyMap<ContractAddress, u64>,
    }
    
    #[external(v0)]
    fn stake_for_worker(
        ref self: ContractState,
        worker_address: ContractAddress,
        amount: u256
    ) {
        let caller = get_caller_address();
        
        // 💸 Transfer CIRO tokens to pool
        let ciro_token = ICiroToken { 
            contract_address: self.ciro_token_address.read() 
        };
        ciro_token.transfer_from(caller, get_contract_address(), amount);
        
        // 📈 Update stake records
        let current_stake = self.worker_stakes.read(worker_address);
        self.worker_stakes.write(worker_address, current_stake + amount);
        self.total_stake.write(self.total_stake.read() + amount);
        
        // 🎉 Emit staking event
        self.emit(WorkerStaked { worker_address, amount, total_stake: current_stake + amount });
    }
}

⛽ Gas Optimization Strategy

📊 Real-Time Performance Analytics

🔥 Hardware Utilization Matrix

💻 WORKER PERFORMANCE (Live Data):

GPU Model          Utilization    Jobs/Hour    Revenue/Hour    Efficiency
────────────────────────────────────────────────────────────────────────
🚀 H100 SXM 80GB   ████████ 78%      127         $3.20        ⭐⭐⭐⭐⭐
🎯 A100 80GB       ███████░ 71%       94         $2.40        ⭐⭐⭐⭐
🎮 RTX 4090        ████████ 85%       73         $1.80        ⭐⭐⭐⭐
⚡ RTX 3080        ████████ 89%       45         $0.90        ⭐⭐⭐

🌍 Geographic Distribution

Global Compute Distribution:

📈 Scaling Projections

🚀 Network Growth Trajectory (6 Months):

🛡️ Multi-Layer Security Architecture

🔐 Security Stack Overview

graph TB
    subgraph "🌐 Network Security"
        TLS[🔒 TLS 1.3<br/>End-to-End Encryption]
        ED[✍️ Ed25519<br/>Digital Signatures]
        AES[🛡️ AES-256-GCM<br/>Symmetric Encryption]
    end
    
    subgraph "💰 Economic Security"  
        STAKE[💎 Stake-Weighted Voting<br/>Economic Alignment]
        SLASH[⚔️ Progressive Slashing<br/>Graduated Penalties]
        REP[🏆 Reputation System<br/>Historical Performance]
    end
    
    subgraph "🔮 Cryptographic Security"
        ZK[🧮 Zero-Knowledge Proofs<br/>Privacy Preservation]
        STARK[✨ STARK Verification<br/>Computational Integrity]
        HASH[#️⃣ Poseidon Hashing<br/>ZK-Friendly]
    end
    
    TLS --> STAKE
    ED --> SLASH
    AES --> REP
    
    STAKE --> ZK
    SLASH --> STARK
    REP --> HASH
    
    style TLS fill:#dc2626,color:#fff
    style STAKE fill:#059669,color:#fff
    style ZK fill:#7c3aed,color:#fff

🏥 Compliance Framework

🚀 Development Ecosystem

🛠️ SDK & Integration Tools

// 🎯 TypeScript SDK - Production Ready
import { CiroClient, ModelConfig, VerificationLevel } from '@ciro-network/sdk';

const client = new CiroClient({
    network: 'mainnet',        // 🌐 Network selection
    apiKey: process.env.CIRO_API_KEY,
    verification: VerificationLevel.ZKML,  // 🔮 Proof generation
    timeout: 30000,           // ⏱️ Request timeout
    retries: 3,               // 🔄 Auto-retry logic
    region: 'us-east-1'       // 🌍 Geographic preference
});

// 🚀 Deploy and run verifiable AI
const result = await client.infer({
    modelId: 'resnet50-production',
    input: imageBuffer,
    generateProof: true,      // ✅ Cryptographic verification
    priority: 'high',         // ⚡ Execution priority
    maxLatency: 500          // 📊 SLA requirements
});

console.log(`🎯 Prediction: ${result.output}`);
console.log(`📊 Confidence: ${result.confidence}`);
console.log(`✨ Proof Hash: ${result.proofHash}`);
console.log(`⛓️ Verified: ${result.onChainVerified}`);

# 🐍 Python SDK - ML Engineer Friendly
from ciro_sdk import CiroClient, VerificationLevel
import numpy as np

client = CiroClient(
    network="mainnet",
    verification=VerificationLevel.ZKML,
    gpu_preference="H100"  # 🚀 Target enterprise hardware
)

# 🧠 Load your model and run verifiable inference
model_deployment = client.deploy_model(
    framework="pytorch",
    model_path="./models/transformer.onnx",
    optimization="fp16",     # ⚡ Performance optimization
    verification=True        # 🔮 Enable proof generation
)

result = client.infer(
    model_id=model_deployment.id,
    input_data=tokenized_text,
    batch_size=32,           # 📊 Batch processing
    generate_proof=True      # ✅ Cryptographic guarantee
)

🎨 Framework Integrations

🗺️ Technical Roadmap

📅 Quarterly Milestones

gantt
    title 🚀 Ciro Network Development Timeline
    dateFormat  YYYY-MM-DD
    section Foundation
    Core pBFT consensus           :done, foundation1, 2024-01-01, 2024-03-31
    Basic zkML support           :done, foundation2, 2024-02-01, 2024-04-30
    Kafka job orchestration      :done, foundation3, 2024-03-01, 2024-05-31
    
    section Scaling  
    Advanced zkML (Transformers) :active, scaling1, 2024-06-01, 2024-09-30
    Multi-GPU worker support     :scaling2, 2024-07-01, 2024-10-31
    Cross-chain verification     :scaling3, 2024-08-01, 2024-11-30
    
    section Optimization
    Proof batching & aggregation :optimization1, 2024-10-01, 2025-01-31
    FHE privacy features         :optimization2, 2024-11-01, 2025-02-28
    Federated learning           :optimization3, 2024-12-01, 2025-03-31
    
    section Ecosystem
    AI model marketplace         :ecosystem1, 2025-01-01, 2025-06-30
    Decentralized training       :ecosystem2, 2025-03-01, 2025-08-31
    Cross-platform AI oracles    :ecosystem3, 2025-06-01, 2025-12-31

🎯 Performance Targets

🔬 Scientific Research Foundation

📚 Core Academic Papers

🎓 Peer-reviewed research backing every architectural decision

1. 🛡️ Byzantine Consensus: Lamport et al. (1982) - "The Byzantine Generals Problem"

   • Foundation for fault-tolerant distributed systems

2. ⚡ Practical Implementation: Castro & Liskov (1999) - "Practical Byzantine Fault Tolerance"

   • Production-ready consensus algorithms

3. 🔮 Zero-Knowledge Proofs: Goldwasser et al. (1989) - "Knowledge Complexity of Interactive Proof Systems"

   • Cryptographic foundation for verifiable computation

4. ✨ STARK Technology: Ben-Sasson et al. (2018) - "Scalable, transparent, post-quantum secure computational integrity"

   • Modern zero-knowledge proof systems

🧮 Mathematical Models

Network Efficiency Coefficient:

η = (Σᵢ Cᵢ × Uᵢ × Rᵢ) / (Σᵢ Cᵢ × Pᵢ)

Where:
• η = Network efficiency (0.0 - 1.0)
• Cᵢ = Compute capacity of worker i (TFLOPS)  
• Uᵢ = Utilization rate of worker i (0.0 - 1.0)
• Rᵢ = Reliability score of worker i (0.0 - 1.0)
• Pᵢ = Peak theoretical performance of worker i

Economic Security Scaling:

S(n,f) = min(Economic_Security(n,f), Byzantine_Security(n,f))

Where:
• Economic_Security(n,f) = Σᵢ₌₁ⁿ Stakeᵢ × Slashing_Rateᵢ
• Byzantine_Security(n,f) = 1 if n ≥ 3f + 1, else 0
• n = total validators, f = Byzantine failures

🌟 What's Next?

🧠 For Technical Teams

graph LR
    A[📖 Read This Guide] --> B[🔮 Explore ZK-ML Details]
    B --> C[⛓️ Smart Contract Integration]  
    C --> D[🚀 Build Your First dApp]
    
    style A fill:#3b82f6,color:#fff
    style B fill:#7c3aed,color:#fff
    style C fill:#059669,color:#fff
    style D fill:#dc2626,color:#fff

🔬 For Researchers

• 📝 Academic Collaboration: Join our research working groups
• 🔓 Open Source: Contribute to GitHub repositories
• 🔍 Peer Review: Validate mathematical models and implementations
• 💡 Innovation Labs: Propose novel ZK-ML applications

🏢 For Enterprises

• 🚀 POC Development: Build proof-of-concepts on testnet
• 🛡️ Security Audits: Participate in security review process
• 📋 Integration Planning: Design enterprise AI workflows
• 🤝 Strategic Partnerships: Explore collaboration opportunities

🎯 The future of AI is verifiable, decentralized, and built on scientific principles.
Ready to be part of the revolution? Explore our architecture components and start building today! 🚀

🛠️ System Overview

Welcome to the Ciro Network technical overview! Whether you’re a developer, researcher, or just curious about how it all works, this page will give you a clear, high-level understanding of our architecture and core components.

🌐 What is Ciro Network?

Ciro Network is a decentralized, multichain compute layer that connects GPU providers with users who need verifiable, high-performance AI and data jobs. It combines smart contracts, distributed nodes, and cryptographic proofs to deliver trustless compute—open to all.

🏗️ High-Level Architecture

graph TD
  User["User / dApp"] -->|Submit Job| JobMgr["Job Manager (Starknet)"]
  JobMgr -->|Escrow, Staking, Registry| CDC["CDC Pool (Starknet)"]
  JobMgr -->|Job Spec| Coord["Coordinator Node (Rust)"]
  Coord -->|Dispatch| Worker["Worker Node (GPU Provider)"]
  Worker -->|Result + Proof| Coord
  Coord -->|Receipt| JobMgr
  JobMgr -->|Settlement| Bridge["Cross-Chain Bridge"]
  Bridge -->|Payout| L1["Ethereum / Polygon / Other L1s"]
  JobMgr -->|Events| SDK["SDKs / APIs"]

🧩 Core Components

• Smart Contracts (Starknet, Multichain)
  • Job Manager: Escrow, staking, job registry, slashing
  • CDC Pool: Compute rewards, performance tracking
  • Governance Treasury: DAO, multi-sig, timelock
  • Bridges: Cross-chain settlement and staking
• Coordinator Node (Rust)
  • Batches jobs, dispatches to workers, submits receipts
  • Handles network health, reputation, and job allocation
• Worker Nodes (GPU Providers)
  • Run AI/data jobs, generate cryptographic proofs (ZK-ML)
  • Stake CIRO tokens, earn rewards, report performance
• Bridges & Multichain Settlement
  • Settle jobs and staking on Starknet, Ethereum, Polygon, and more
  • Bridge results and funds across chains
• SDKs & APIs
  • JavaScript, Python, and multi-chain SDKs for easy integration
  • CLI and web UI for job submission and monitoring

✨ Key Features

• Verifiable Compute: ZK-ML proofs for trustless results
• Multichain Settlement: Pay and stake on your preferred chain
• Staking & Slashing: Economic security for users and providers
• Open Participation: Anyone can join as a user or provider
• Decentralized Governance: DAO, multi-sig, and timelock controls
• Performance Bonuses: Rewards for uptime, speed, and zkML jobs

🔄 How It All Fits Together: Job & Settlement Flow

1. User submits a job (AI inference, data processing, etc.) via SDK, CLI, or web UI
2. Job Manager contract escrows payment, checks staking, and registers the job
3. Coordinator node batches and dispatches the job to available worker nodes
4. Worker node runs the job, generates a cryptographic proof, and returns the result
5. Coordinator submits receipt to the Job Manager
6. User retrieves results and proof; payment is released to the provider
7. Settlement: Funds and rewards can be bridged to Ethereum, Polygon, or other chains as needed

📚 Learn More

• Smart Contracts Deep Dive
• Coordinator Node Architecture
• Staking & Tokenomics
• zkML & Proofs
• Multichain & Bridges
• Getting Started Guides

Have questions? Join our Discord or check out the rest of the docs for more details!

✨ The Magic of ZK-ML

Welcome! If you’ve ever wondered how Ciro Network can guarantee the results of AI jobs—without trusting any single party—this page is for you. Here’s how Zero-Knowledge Machine Learning (ZK-ML) makes it possible.

🤔 What is ZK-ML?

ZK-ML stands for Zero-Knowledge Machine Learning. It’s a breakthrough technology that lets someone prove they ran an AI model correctly—without revealing the model’s secrets or the raw data.

• Zero-Knowledge Proofs (ZKPs): Cryptographic techniques that prove a statement is true, without revealing why it’s true.
• ZK-ML: Applies ZKPs to machine learning, so you can prove “I ran this model on this data and got this result”—and anyone can verify it.

🔒 Why Does It Matter?

• Trustless Results: No need to trust the GPU provider, the network, or even the model creator. The proof is math.
• Privacy: Sensitive data and proprietary models stay private—only the result and proof are shared.
• Verifiability: Anyone (users, dApps, smart contracts) can check the proof and know the result is correct.
• New Use Cases: Enables DeFi, DAOs, and on-chain games to use AI safely and transparently.

⚙️ How Does Ciro Use ZK-ML?

1. User submits a job (e.g., image recognition, risk scoring)
2. Worker node runs the AI model on their GPU
3. Worker generates a ZK-ML proof that the computation was done correctly
4. Proof and result are sent back to the user (and optionally, on-chain)
5. Anyone can verify the proof—on Starknet, Ethereum, or other chains

🛠️ Under the Hood

• Ciro integrates with leading ZK-ML frameworks (Orion, Giza, RISC Zero, etc.)
• Proofs are generated off-chain (on the worker’s GPU/CPU)
• Verification can happen on-chain (Starknet) or off-chain (SDK, API)

🖼️ Visual: ZK-ML Job Flow

graph TD
  User["User / dApp"] -->|Submit Job| Worker["Worker Node (GPU)"]
  Worker -->|Run Model| Model["AI Model"]
  Model -->|Result + ZK-ML Proof| Worker
  Worker -->|Result + Proof| User
  User -->|Verify Proof| Verifier["On-chain / Off-chain Verifier"]

🌍 Real-World Examples

• DeFi Oracles: Prove an AI model generated a price feed, without revealing the model or data
• On-Chain Games: Prove a game AI made a move fairly, without leaking strategy
• Enterprise AI: Prove compliance or auditability for sensitive predictions
• Research: Share results with cryptographic guarantees, protecting IP and privacy

📚 Learn More

• ZK-ML Research
• Ciro Smart Contracts
• Job & Proof Flow
• Getting Started Guides

Questions? Join our Discord or explore the rest of the docs for more details!

🟣 Starknet & Cairo: Our Foundation

Welcome! If you’re curious why Ciro Network is built on Starknet and Cairo, this page is for you. Here’s how these technologies power our vision for open, verifiable compute.

🤔 What is Starknet? What is Cairo?

• Starknet is a next-generation, zero-knowledge (ZK) Layer 2 network for Ethereum. It brings massive scalability, low fees, and strong security—while keeping everything provable and open.
• Cairo is the programming language for Starknet smart contracts. It’s designed for ZK proofs, enabling complex logic and cryptography to run efficiently on-chain.

🚀 Why Did Ciro Choose Starknet & Cairo?

• Verifiability: Starknet’s ZK tech lets us prove every job, payment, and stake is correct—on-chain, for anyone to check.
• Scalability: Handle thousands of jobs per second, with low fees and fast finality.
• Security: Inherits Ethereum’s security, with extra protection from ZK proofs.
• Innovation: Cairo enables advanced features (ZK-ML, upgradability, multichain bridges) that aren’t possible on older chains.
• Community: Starknet is open, fast-growing, and developer-friendly—perfect for a global, collaborative project like Ciro.

⚙️ How Does Ciro Use Starknet?

• Smart Contracts: All core logic (job management, staking, rewards, governance) lives on Starknet, written in Cairo.
• Settlement: Jobs and payments are settled on Starknet, with bridges to Ethereum, Polygon, and more.
• ZK-ML Proofs: Starknet verifies cryptographic proofs of AI jobs, making results trustless and transparent.
• Multichain: Starknet acts as the “hub” for Ciro’s multichain architecture, connecting to other L1s and L2s.

🏗️ Visual: Ciro on Starknet

graph TD
  User["User / dApp"] -->|Submit Job| JobMgr["Job Manager (Starknet)"]
  JobMgr -->|Escrow, Staking, Registry| CDC["CDC Pool (Starknet)"]
  JobMgr -->|Settlement| Bridge["Cross-Chain Bridge"]
  Bridge -->|Payout| L1["Ethereum / Polygon / Other L1s"]
  JobMgr -->|Events| SDK["SDKs / APIs"]

🌍 Real-World Impact

• AI for DeFi: Trustless oracles and risk models, secured by ZK proofs
• Open Compute: Anyone can join, earn, and verify results—no gatekeepers
• Enterprise-Ready: Auditable, compliant, and scalable for real-world use
• Global Collaboration: Developers, providers, and users from every continent

📚 Learn More

• Starknet Official Docs
• Cairo Language
• Ciro Smart Contracts
• System Overview
• Getting Started Guides

Questions? Join our Discord or explore the rest of the docs for more details!

Smart Contracts Deep Dive

Welcome to the engine room of Ciro Network. Our smart contracts, built on Starknet with Cairo, are the transparent, immutable heart of our decentralized AI compute marketplace. This document provides a technical overview for developers, auditors, and curious minds.

📜 Deployed Contracts & Addresses

Note: Mainnet addresses will be published after security audits and community validation. For the latest addresses, see docs.ciro.network/contracts.

🏛️ Core Architecture: A Three-Pillar System

Our on-chain infrastructure is built on three core pillars that work in concert to manage the lifecycle of a compute job:

1. JobManager.cairo: The central coordinator. It handles job submissions, worker assignments, state transitions, and payment settlements. Think of it as the network's universal remote control.
2. CDC_Pool.cairo (Compute Data & Consensus Pool): The resource and consensus hub. This contract manages worker registration, staking, reputation, and the crucial task of selecting the best worker for a given job.
3. CIRO_Token.cairo: The economic engine. An ERC20-compliant token that powers payments, staking, rewards, and governance on the network.

A high-level view of contract interactions.

🔬 Pillar 1: JobManager.cairo - The Orchestrator

The JobManager is where the journey of every compute task begins and ends. It's a finite state machine that meticulously tracks each job through its lifecycle.

Key Responsibilities:

• Job Submission (submit_ai_job):

  • A client submits a JobSpec (detailing the AI model, inputs, and requirements) and locks payment in the contract.
  • A unique JobId is generated.
  • An on-chain event JobSubmitted is emitted for indexing and transparency.

• State Management:

  • The contract tracks the state of each job: Pending, Assigned, Completed, Failed.
  • The job_states mapping (Map<JobId, JobState>) provides a canonical, on-chain record of every job's status.

• Worker Assignment:

  • The JobManager calls out to the CDC_Pool to select the most suitable, high-reputation worker for the job.
  • Once a worker is selected, the job state is updated to Assigned.

• Verification & Completion (complete_job):

  • After off-chain computation, the assigned worker submits the JobResult.
  • Depending on the VerificationMethod specified in the JobSpec, the contract will trigger the appropriate on-chain verification (e.g., ZK-proof verification).
  • Upon successful verification, the state moves to Completed.

• Payment Settlement (release_payment):

  • Once a job is Completed, the JobManager facilitates the transfer of funds.
  • It uses its IERC20Dispatcher to send the payment from the locked funds to the worker, minus a small platform_fee_bps which is sent to the treasury.

Core Storage Mappings:

The JobManager relies on a set of Map structures to store all critical data on-chain:

• job_specs: Map<JobId, JobSpec>: The detailed specification for each job.
• job_clients: Map<JobId, ContractAddress>: Who submitted the job.
• job_workers: Map<JobId, ContractAddress>: Who is executing the job.
• job_payments: Map<JobId, u256>: The payment amount locked for the job.

// Simplified Storage from JobManager.cairo
#[storage]
struct Storage {
    // ...
    next_job_id: u256,
    job_states: Map<felt252, JobState>,
    job_clients: Map<felt252, ContractAddress>,
    job_workers: Map<felt252, ContractAddress>,
    job_payments: Map<felt252, u256>,
    // ...
}

🤝 Pillar 2: CDC_Pool.cairo - The Trust Layer

If the JobManager is the brain, the CDC_Pool is the heart, pumping trust and reputation throughout the network. It ensures that only honest and capable workers are assigned to jobs.

Key Responsibilities:

• Worker Registration & Staking:

  • GPU providers register as workers by staking CIRO tokens, signaling their commitment to the network.
  • Their hardware capabilities and specifications are stored on-chain.

• Reputation & Slashing:

  • The pool maintains a reputation score for each worker based on performance (successful jobs, uptime, etc.).
  • Malicious or faulty workers can have their stake "slashed" (confiscated) as a penalty, creating a strong economic disincentive against bad behavior.

• Worker Selection Algorithm:

  • When the JobManager requests a worker, the CDC_Pool runs its sophisticated selection algorithm.
  • This algorithm considers:
    • Reputation Score: Prioritizes trusted workers.
    • Stake Size: Higher stake signals more skin-in-the-game.
    • Hardware Match: Ensures the worker meets the JobSpec's requirements.
    • Randomness: Prevents centralization and provides fairness.

💸 Pillar 3: CIRO_Token.cairo - The Economic Fuel

The CIRO token is the lifeblood of the network, a standard ERC20 token supercharged with utility.

Core Utilities:

• Payment for Compute: The primary medium of exchange for AI jobs.
• Staking for Security: Workers stake CIRO to participate and earn rewards.
• Governance: CIRO holders can vote on protocol upgrades and treasury allocations.
• Incentives: A portion of network fees is used for community grants and ecosystem development.

🌊 The Job Lifecycle: An On-Chain Journey

Let's trace a single AI job from creation to completion:

1. Submission: A user calls submit_ai_job on JobManager, locking CIRO tokens.
2. Selection: JobManager requests a worker from CDC_Pool.
3. Assignment: CDC_Pool selects the best worker and informs JobManager.
4. Execution: The worker performs the AI computation off-chain.
5. Completion & Verification: The worker submits the result and ZK proof to JobManager. The proof is verified on-chain.
6. Settlement: JobManager calls CIRO_Token's transfer function to pay the worker and the treasury.
7. Reputation Update: JobManager informs CDC_Pool of the successful job, which updates the worker's reputation score.

This entire process is transparent, verifiable, and governed by immutable code on Starknet, creating a truly trustless marketplace for AI compute.

🛡️ Upgradeability & Contract Management

Ciro contracts are designed for long-term security and flexibility:

• Upgradeable Patterns: We use UUPS and Diamond proxy patterns for safe upgrades, with all changes gated by DAO governance and timelocks.
• Multi-Sig Controls: Critical functions (upgrades, treasury, emergency pause) require multi-signature approval from trusted council members.
• Timelocks: All upgrades and treasury actions are subject to configurable delays, giving the community time to review and react.
• Audit Trail: Every upgrade, parameter change, and critical action is logged on-chain for transparency.

🌉 Multichain & Bridging Strategy

Ciro is built for a multichain world:

• Starknet as the Hub: All core logic and settlement happens on Starknet for speed, security, and ZK verifiability.
• Bridges: We deploy bridge contracts to Ethereum, Polygon, and other L1s/L2s, enabling users to settle jobs and stake on their preferred chain.
• Cross-Chain Proofs: ZK-ML proofs and job receipts can be verified on any supported chain, unlocking new use cases in DeFi, gaming, and beyond.
• Future-Proofing: Contracts are modular and upgradeable, ready to support new chains and standards as the ecosystem evolves.

For the latest contract addresses, ABI files, and deployment scripts, visit our GitHub or join our Discord for real-time updates.

🧮 Mathematical Models & Economic Equations

From Factory Floor to Algorithm: The Mathematical Heart of Decentralized Compute

When Ciro Network was born from the practical need to optimize factory operations, we didn't just build another compute network—we built a mathematically rigorous economic machine. Every equation here has been battle-tested in real-world scenarios, from predicting GPU performance to optimizing worker rewards.

🌟 Why Mathematics Matters in DePIN

In traditional centralized computing, mathematics hides behind corporate black boxes. At Ciro Network, every economic decision, every performance metric, and every security guarantee is governed by transparent, peer-reviewed mathematical models that anyone can verify, understand, and improve.

The Three Pillars of Mathematical Design

1. 🎯 Economic Incentives: Game theory ensures honest behavior
2. ⚡ Performance Optimization: Calculus maximizes network efficiency
3. 🛡️ Security Guarantees: Cryptographic proofs protect against attacks

📐 Core Network Efficiency Models

The Ciro Efficiency Coefficient

Our flagship equation quantifies how well the network converts raw compute power into productive work. This model emerged from analyzing thousands of hours of factory floor GPU utilization data.

Real-World Application: A network with efficiency $\eta = 0.85$ means 85% of theoretical compute capacity is being converted into productive work—industry-leading performance.

Interactive Efficiency Calculator

Wolfram Alpha Analysis - Network Efficiency vs Worker Count:

plot (80*0.95*1.1/120) for x from 1 to 50

🔗 Calculate Network Efficiency

Performance Prediction Model

Our AI-powered performance predictor uses historical data to forecast job completion times:

🛡️ Economic Security & Game Theory

Byzantine Fault Tolerance with Economic Stakes

Traditional BFT assumes up to 33% malicious actors. Ciro Network's economic model makes attacks exponentially more expensive as the network grows.

Slashing and Penalty Mathematics

When workers misbehave, our algorithmic justice system applies proportional penalties:

Wolfram Alpha Demo - Penalty Escalation:

plot 0.05*(1 + x^2/(1 - x)) from x = 0 to 0.9

🔗 Explore Penalty Curves

⚡ Performance & Throughput Optimization

Latency Distribution Model

Based on real-world network measurements across 50+ countries:

Throughput Scaling Laws

How job processing capacity scales with network size:

Wolfram Alpha Visualization - Throughput Scaling:

plot 10000*(1 - exp(-x/500))*(1 - 100/(x + 100)) from x = 0 to 2000

🔗 Interactive Throughput Analysis

💰 CIRO Token Economics

Dynamic Fee Discovery

Our fee model balances affordability with network sustainability:

Staking Rewards Optimization

Rewards are distributed to maximize network health and participation:

Wolfram Alpha Demo - Sublinear Staking Rewards:

plot {x, x^0.8} from x = 0 to 1000

🔗 Compare Linear vs Sublinear Rewards

🔮 Zero-Knowledge Proof Mathematics

STARK Proof Generation Complexity

Cairo-based STARKs provide verifiable compute with logarithmic verification:

Verification Efficiency

STARK verification scales logarithmically with computation size:

Wolfram Alpha Analysis - Proof System Performance:

logplot {2.3*10^(-6)*x*log(x) + 0.075, 0.005 + 0.0001*(log(x))^2} from x = 1000 to 10^8

🔗 Analyze Proof Complexity

📈 Network Growth & Adoption Models

Modified Metcalfe's Law for DePIN

Network value grows super-linearly with active participants, but with diminishing returns:

S-Curve Adoption with Network Effects

Real-world adoption follows an enhanced logistic model:

Wolfram Alpha Simulation - Adoption Curves:

plot 1000000/(1 + exp(-0.15*(x - 18)))*(1 + 0.1*sin(2*pi*x/12)) from x = 0 to 60

🔗 Model Adoption Scenarios

🧪 Economic Analysis Tools

GPU Provider ROI Analysis

Simple ROI Calculation for GPU Providers:

Daily revenue for a 400W GPU at 70% utilization:

400 * 0.7 * 24 * 0.50 / 1000

🔗 Calculate Daily GPU Revenue

Monthly Profit Analysis:

plot (400 * 0.7 * 24 * x / 1000 * 30) - (400 * 24 * 0.12 / 1000 * 30 + 100) from x = 0.1 to 2

🔗 Analyze Monthly GPU Profits by Rate

Network Security Economics

Attack Cost Analysis:

Cost to control 33% of network with 1000 workers:

1000 * 10000 / 3

🔗 Calculate 33% Attack Cost

Economic Security vs Network Size:

plot {x*10000/3, 1000000*exp(0.1*x)} from x = 10 to 1000

🔗 Security vs Network Size

📊 Real-Time Network Analytics

Live Mathematical Metrics

Our network continuously computes these key performance indicators:

Mathematical Health Score

The overall network health combines multiple mathematical indicators:

Network Health Calculator:

0.3*0.85 + 0.25*0.9 + 0.25*0.8 + 0.2*0.95

🔗 Calculate Example Health Score

💡 Interactive Mathematical Comparisons

Ciro vs Traditional Cloud Costs

Compare costs over time:

plot {2.5*x, 1.2*x} from x = 0 to 8760

🔗 Compare Annual Costs: AWS vs Ciro

Token Supply Dynamics

CIRO token inflation vs burn with network growth:

plot {1000000000*(1 + 0.05*x), 1000000000*(1 - 0.02*x)} from x = 0 to 10

🔗 Model Token Supply Over Years

Worker Performance Distribution

Normal distribution of worker performance ratings:

plot normal distribution mean=7.5 standard deviation=1.2

🔗 Worker Performance Bell Curve

🎯 Mathematical Research & Development

Open Research Questions

Ciro Network continues to push the boundaries of DePIN mathematics:

1. 🧠 AI-Optimized Worker Selection: Machine learning models for optimal job-worker matching
2. ⚡ Cross-Chain Economic Models: Mathematical frameworks for multi-blockchain value transfer
3. 🌍 Geographic Load Balancing: Optimization algorithms for global compute distribution
4. 🔮 Predictive Network Scaling: Early warning systems for congestion and capacity planning

Academic Collaborations

We're working with leading universities on:

• Stanford: Advanced cryptoeconomic mechanism design
• MIT: Zero-knowledge proof optimization algorithms
• UC Berkeley: Decentralized systems game theory
• ETH Zurich: Blockchain scalability mathematics

🚀 What's Next in Mathematical Innovation?

Upcoming Features

• 📈 Real-time Optimization Engine: Live mathematical model adjustments
• 🧮 Custom Economic Models: User-defined incentive mechanisms
• 📊 Advanced Analytics Dashboard: Mathematical insights for all participants
• 🔬 Mathematical Simulation Sandbox: Test economic changes before deployment

Get Involved

• 📚 Research Repository: github.com/ciro-network/research
• 🧮 Mathematical Forums: discuss.ciro.network/mathematics
• 📊 Real-time Dashboard: analytics.ciro.network
• 💡 Improvement Proposals: proposals.ciro.network

"In mathematics we trust, in transparency we verify, in community we innovate."

Every equation on this page represents real value being created, real problems being solved, and real people being empowered through mathematically sound decentralized computing. Ready to contribute to our mathematical future? 🚀

Next Steps:

• 🔧 Start Building with our mathematical APIs
• 💰 Become a Provider and start earning with proven models
• 🧮 Research with Us and shape the mathematical future of DePIN

🪙 CIRO Tokenomics: Powering the Future of Decentralized Compute

From Factory Floor to Global Network: The Story of CIRO

Ciro Network was born not in a hackathon, but on a real factory floor—where the need for fair, transparent, and efficient compute was more than just a theory. The CIRO token is the heartbeat of this mission, aligning incentives for everyone: providers, users, developers, and the community.

🌟 What is the CIRO Token?

The CIRO token is the native digital asset of the Ciro Network. It is designed to:

• Incentivize compute providers to contribute GPU power
• Reward users for honest participation and job completion
• Enable decentralized governance—every token holder has a voice
• Secure the network through staking and slashing
• Fuel a multichain, cross-domain compute economy

🔢 Token Supply, Inflation & Burn

• Why inflation? To reward early contributors and bootstrap the network
• Why burn? To ensure long-term scarcity and value alignment

💸 Staking, Providing & Earning

Anyone can participate in the Ciro Network economy:

• GPU Providers: Stake CIRO to register, earn rewards for jobs, and boost reputation
• Users: Pay for compute jobs in CIRO, benefit from lower fees as the network grows
• Stakers: Delegate tokens to providers and share in network rewards

Rewards are distributed based on:

• Amount staked
• Performance (job success rate, uptime)
• Network utilization

Learn more about Staking →

🗳️ Governance: Shape the Future

CIRO token holders are the ultimate decision-makers:

• Propose and vote on protocol upgrades
• Adjust economic parameters (fees, inflation, rewards)
• Elect council members and approve major initiatives

Governance is on-chain, transparent, and open to all. Your voice matters!

Read about Governance →

🌉 Multichain & Upgradeability

• Starknet is the home of the CIRO token and core contracts
• Bridges to Ethereum, Polygon, Arbitrum, and Base enable cross-chain staking and settlement
• Upgradeable contracts allow the protocol to evolve with community consensus

Deployed CIRO Token Address (Starknet):

0x03c0f7574905d7cbc2cca18d6c090265fa35b572d8e9dc62efeb5339908720d8

📊 Economics & Deeper Reading

• Token Model & Emissions
• Staking & Rewards
• Governance
• Treasury & Fees
• Mathematical Models

🤗 Join the Ciro Community

Whether you're a GPU provider, developer, researcher, or just curious—you belong here. The Ciro Network is built by and for its community. Every CIRO token is a piece of our shared future.

Ready to get started?

• Become a Provider
• Start Building
• Join the Conversation

“Incentives, transparency, and community—mathematically aligned.”

🪙 The CIRO Token: The Heartbeat of Decentralized Compute

Born from Real-World Need, Built for Global Impact

The CIRO token isn’t just another digital asset—it’s the economic engine that powers the Ciro Network. Conceived on a factory floor, CIRO was designed to solve real problems: fair rewards, transparent governance, and unstoppable security for a new era of decentralized compute.

🌟 What is the CIRO Token?

The CIRO token is the native, governance-enabled, and utility-rich digital asset of the Ciro Network. It is:

• The fuel for compute jobs—pay for and earn rewards in CIRO
• A governance key—propose, vote, and shape the protocol’s future
• A security anchor—stake to secure the network, with slashing for bad actors
• A community badge—the more you participate, the more your voice grows

🔑 Core Features (from Smart Contracts)

🏛️ Progressive Governance & Voting Power

• On-chain proposals: Anyone can propose upgrades, parameter changes, or treasury actions
• Voting power multipliers: The longer you hold, the more your vote counts (veteran/long-term multipliers)
• Supermajority and quorum: Critical changes require 67%+ and high participation
• Anti-spam: Proposal cooldowns and limits per user
• Emergency council: Can pause or intervene in case of attack

🛡️ Security & Emergency Features

• Slashing: Bad actors lose staked tokens (malicious, unavailable, protocol violation, fraud)
• Rate limits: Prevent manipulation and large, sudden transfers
• Audit tracking: Security reviews and findings are tracked on-chain
• Emergency withdrawal: Council can act to defend the protocol
• Upgradeable: All changes require on-chain governance and/or council approval

🌉 Deployed Address & Source

• Starknet Address:

0x03c0f7574905d7cbc2cca18d6c090265fa35b572d8e9dc62efeb5339908720d8

• View Contract Source on GitHub

📚 Learn More

• Staking, Providing & Earning
• Governance & Treasury
• Token Model & Emissions
• Mathematical Models

Every CIRO token is a piece of our shared future. Welcome to the network!

💸 Staking, Providing & Earning: Powering the Ciro Network

From Your GPU to the World: Everyone Can Earn

Ciro Network is built for everyone—from solo GPU owners to institutional providers. Staking is your ticket to participate, earn, and help secure the future of decentralized compute.

🌱 What is Staking?

Staking means locking up CIRO tokens to:

• Prove your commitment to the network
• Gain the right to provide compute jobs
• Earn rewards for honest work
• Help secure the protocol (bad actors are slashed)

Staking aligns everyone’s incentives—when the network wins, you win.

🖥️ How to Become a Provider

1. Register your worker: Submit hardware proof, location, and capabilities
2. Stake CIRO tokens: Meet the minimum for your desired tier (see below)
3. Start earning: Get matched to jobs, build your reputation, and grow your rewards

🏆 Staking Tiers & Benefits

• The more you stake, the more you can earn and influence the network.
• Tiers are based on the USD value of CIRO at the time of staking.

🎁 How Rewards Work

• Base reward: Every completed job pays a base CIRO amount
• Performance multiplier: Higher reputation = bigger rewards
• Network utilization: More jobs, more rewards for everyone
• Pending rewards: Claimable after job completion and verification

Example:

Alice stakes at the Premium tier, completes 10 jobs with high reputation, and earns more than Bob at Basic tier with lower reputation.

⚠️ Slashing: Security for All

• Why? To keep the network honest and safe
• Reasons:
  • Malicious behavior (50%+ slashed)
  • Unavailability (10%)
  • Poor performance (20%)
  • Protocol violation (30%)
  • Fraud (100%)
• How? Slashed tokens are burned or sent to the treasury

🔄 Unstaking: How to Exit

• Request unstake: Submit a request (cooldown applies)
• Cooldown period: Varies by tier and recent activity
• Tokens returned: After cooldown, tokens are unlocked and returned
• Why cooldown? Prevents abuse and ensures network stability

🤝 Delegators: Earn Without Running Hardware

• Don’t have a GPU? You can still earn by delegating CIRO to trusted providers
• Share in rewards: Delegators receive a portion of provider earnings
• Support the network: More staked CIRO = stronger, more secure protocol

📚 Learn More

• CDC Pool: How Jobs & Rewards Work
• Governance & Treasury
• Token Model & Emissions

Staking is for everyone. Whether you’re a solo provider or a global datacenter, Ciro Network welcomes you.

🗳️ Governance: Shape the Future of Ciro Network

From Factory Floor to DAO: Real-World Governance for Real Impact

Ciro Network’s governance isn’t just code—it’s a living, breathing community process. Inspired by real-world collaboration, our on-chain governance ensures every voice matters, every decision is transparent, and the protocol evolves with its people.

🌍 What is On-Chain Governance?

On-chain governance means all major decisions are made by the community, on the blockchain, in the open. No backroom deals, no hidden changes—just transparent, auditable, and fair protocol evolution.

📝 How Proposals Work

Anyone with enough CIRO can propose changes, including:

• Protocol upgrades: Add new features, fix bugs, or improve security
• Treasury actions: Fund grants, partnerships, or ecosystem growth
• Parameter changes: Adjust fees, inflation, rewards, or slashing rates
• Emergency actions: Pause the protocol, defend against attacks, or recover funds

Proposal lifecycle:

1. Create: Submit a proposal (must meet minimum token threshold)
2. Discuss: Community reviews and debates the proposal
3. Vote: Token holders vote (weighted by voting power)
4. Execute: If quorum and thresholds are met, the proposal is executed on-chain

🏛️ Voting Power & Participation

• Progressive voting: The longer you hold CIRO, the more your vote counts (veteran/long-term multipliers)
• Quorum: Proposals need enough participation to pass (prevents small groups from making big changes)
• Supermajority: Critical changes (upgrades, treasury) require 67%+ support
• Anti-spam: Cooldowns and proposal limits per user

👥 Council & Multi-Sig: Safety Nets for the Network

• Council: Elected or appointed members with multi-sig authority for emergencies, upgrades, and treasury actions
• Multi-sig: No single person can act alone—major actions require multiple approvals
• Emergency controls: Council can pause the protocol, authorize emergency withdrawals, or defend against attacks

💰 Treasury Management

• On-chain treasury: All funds are managed by the DAO, with full transparency
• Proposals: Anyone can propose treasury actions (grants, investments, buybacks)
• Emergency withdrawal: Council can act quickly if the protocol is threatened
• Audit tracking: All treasury actions are logged and reviewed

🛡️ Security & Safeguards

• Timelocks: Delays before execution give the community time to react
• Audit tracking: Security reviews and findings are public
• Blacklisting: Malicious actors can be excluded by governance
• Upgradeability: All changes require on-chain approval and/or council sign-off

🚀 How to Participate

• Propose: If you have enough CIRO, submit your idea for a vote
• Vote: Use your tokens to support or oppose proposals
• Join the council: Top contributors and institutional partners can be elected to the council
• Discuss: Every proposal is open for community debate—your input matters!

📚 Learn More

• Treasury & Economics
• Token Model
• Staking & Earning
• Mathematical Models

Ciro Network is governed by you. Every vote, every proposal, every discussion shapes our future. Welcome to the table!

🤝 Contribute & Participate: Build Ciro Network Together

From Factory Floor to Open Source: Ciro is Community-Powered

Ciro Network is more than code—it's a movement. Whether you're a developer, researcher, writer, tester, or just curious, you belong here. Every contribution, big or small, helps shape the future of decentralized compute.

🌟 Ways to Contribute

• Code: Smart contracts, node software, desktop apps, backend services
• Documentation: Guides, tutorials, API docs, technical specs
• Testing: Try new features, report bugs, improve reliability
• Research: Distributed systems, DePIN, GPU optimization
• Community: Answer questions, welcome newcomers, share ideas

🚀 Getting Started

1. Fork & Clone:
   • Fork the repo on GitHub, then clone your fork
   • Add the original repo as upstream for updates
2. Set Up Dev Environment:
   • Use DevContainers or follow our setup guide
3. Create a Feature Branch:
   • Use clear, descriptive branch names (e.g., feature/your-feature)

🛠️ Contribution Workflow

• Code Standards: Follow our Code Standards for Rust, Cairo, JS/TS, etc.
• Security: Review our Security Guidelines. Validate inputs, avoid secrets, handle errors, audit dependencies.
• Testing: Include unit, integration, and security tests. See our Testing Guide.
• Documentation: Update READMEs, add inline docs, and keep user guides current. See Documentation Standards.
• Pull Requests:
  • Use our PR template
  • Clear, descriptive commit messages (Conventional Commits)
  • Link related issues, provide screenshots for UI changes
  • All PRs require review and must pass CI/CD

🐛 Reporting Bugs & Requesting Features

• Bugs: Use our Bug Report Guide. Include environment, steps, expected/actual behavior, and logs/screenshots.
• Features: Use our Feature Request Guide. Explain the problem, your solution, and alternatives.
• Security: For vulnerabilities, email security@ciro.ai (do not open a public issue).

💬 Community Guidelines

• Be welcoming: We value every contributor, regardless of background or experience.
• Respectful collaboration: Disagree constructively, help others, and celebrate wins together.
• Code of Conduct: See our Community Guidelines.

📚 Learn More & Dive Deeper

• Contribution Guide
• Code Standards
• Community Guidelines
• Bug Reports
• Feature Requests
• Documentation Standards

Ciro Network is built by people like you. Your ideas, your code, your questions—they all matter. Welcome to the team!

Contribution Guide

Welcome to the Ciro Network community! 🌟

Whether you're a developer, researcher, community builder, content creator, or simply someone passionate about decentralized computing, there's a place for you here. This guide will help you find your path to contributing to our mission of making AI computing accessible to everyone.

🤝 Everyone is Welcome

Ciro Network thrives on diverse perspectives and contributions. You don't need to be a blockchain expert or AI researcher to make a meaningful impact. Here are some ways you can contribute:

💻 For Developers

• Smart Contracts: Help improve our Cairo contracts on Starknet
• Rust Backend: Contribute to our node implementation and coordinator services
• Frontend/UI: Build user interfaces for providers and users
• Testing: Write tests, find bugs, improve reliability
• Documentation: Help make our docs clearer and more accessible

🔬 For Researchers

• ZK-ML: Research zero-knowledge machine learning techniques
• Tokenomics: Analyze and improve our economic models
• Network Design: Study distributed computing architectures
• Security: Audit our smart contracts and protocols
• Performance: Optimize our compute distribution algorithms

🌍 For Community Builders

• Discussions: Participate in community forums and Discord
• Events: Help organize meetups, hackathons, or workshops
• Outreach: Spread the word about decentralized computing
• Support: Help newcomers understand the project
• Feedback: Share your ideas and suggestions

📝 For Content Creators

• Documentation: Write tutorials, guides, and explanations
• Blog Posts: Share insights about decentralized computing
• Videos: Create educational content about Ciro Network
• Graphics: Design diagrams, infographics, and visual content
• Translations: Help make our content available in more languages

💡 For Everyone

• Ideas: Share your thoughts on how to improve the network
• Testing: Try out our tools and provide feedback
• Bug Reports: Help us identify and fix issues
• Feature Requests: Suggest new capabilities you'd like to see
• Questions: Ask questions that help us improve our explanations

🚀 Getting Started

1. Join Our Community

• Discord - Chat with the team and community
• GitHub Discussions - Ask questions and share ideas
• Twitter - Stay updated on latest developments

2. Choose Your Path

• New to the project? Start with our Introduction and Getting Started guides
• Want to run a node? Check out our Provider Guide
• Interested in development? Review our Technical Overview and Contracts
• Curious about the economics? Explore our Tokenomics section

3. Find Your First Contribution

• Look for issues labeled good first issue or help wanted
• Check our Contributing Standards for guidelines
• Join community discussions to understand current priorities
• Don't hesitate to ask questions - we're here to help!

🔧 Development Workflow

If you're contributing code, here's our typical workflow:

1. Fork and Clone

# Fork the repository on GitHub
# Then clone your fork locally
git clone https://github.com/your-username/ciro-network.git
cd ciro-network

2. Set Up Your Environment

# Install dependencies
npm install  # For JavaScript/TypeScript projects
cargo build  # For Rust projects
scarb build  # For Cairo contracts

3. Create a Branch

git checkout -b feature/your-feature-name
# or
git checkout -b fix/issue-description

4. Make Your Changes

• Write clear, well-documented code
• Add tests for new functionality
• Update documentation as needed
• Follow our coding standards

5. Test Your Changes

npm test     # Run JavaScript tests
cargo test   # Run Rust tests
scarb test   # Run Cairo tests

6. Submit a Pull Request

• Write a clear description of your changes
• Reference any related issues
• Include screenshots for UI changes
• Respond to review feedback promptly

📋 Contribution Guidelines

Code Contributions

• Follow our coding standards
• Write clear commit messages
• Include tests for new features
• Update documentation when needed
• Keep PRs focused and manageable

Documentation Contributions

• Write in clear, accessible language
• Include examples and code snippets
• Update links and references
• Consider translations for global accessibility

Community Contributions

• Be respectful and inclusive
• Help newcomers feel welcome
• Share knowledge and resources
• Provide constructive feedback

Bug Reports

• Use our bug report template
• Include steps to reproduce
• Provide system information
• Be patient while we investigate

Feature Requests

• Check if the feature already exists
• Explain the problem you're solving
• Consider the impact on the community
• Be open to discussion and alternatives

🎯 What We Value

Inclusivity

• We welcome contributors from all backgrounds
• We value diverse perspectives and experiences
• We're committed to making our project accessible to everyone

Transparency

• We share our roadmap and decision-making process
• We're open about challenges and trade-offs
• We encourage questions and discussions

Quality

• We strive for excellence in everything we do
• We value thorough testing and documentation
• We prioritize user experience and security

Community

• We believe in the power of collaboration
• We support each other's growth and learning
• We celebrate contributions of all sizes

🆘 Need Help?

Don't hesitate to reach out! We're here to help you succeed:

• General Questions: Join our Discord or GitHub Discussions
• Technical Issues: Check our documentation or create an issue
• Security Concerns: Email us at security@ciro.network
• Partnership Inquiries: Contact us at partnerships@ciro.network

🎉 Recognition

We believe in recognizing and celebrating contributions:

• Contributor Hall of Fame: We maintain a list of significant contributors
• Community Spotlight: We highlight outstanding community members
• Swag and Rewards: Contributors may receive Ciro Network merchandise
• Token Rewards: Active contributors may receive CIRO tokens

📚 Next Steps

Ready to dive deeper? Check out these resources:

• Contributing Standards - Detailed guidelines for code and documentation
• Community Guidelines - How we work together
• Bug Reporting - How to report issues effectively
• Feature Requests - How to suggest new features
• Documentation Guide - How to improve our docs
• Running a Node - How to contribute as a provider

Thank you for being part of our journey! 🌟

Every contribution, no matter how small, helps us build a more accessible and decentralized future for AI computing. Together, we're making the impossible possible.

Questions? Ideas? Just want to say hello? We'd love to hear from you!

Running a Worker Node

Welcome to the Ciro Network! 🌟

Running a worker node is one of the most impactful ways to contribute to our decentralized computing network. Whether you're a GPU owner looking to earn rewards, a developer wanting to test the network, or a community member helping to build the future of AI computing, this guide will help you get started.

🤝 Why Run a Worker Node?

For GPU Owners

• Earn CIRO tokens by providing compute power
• Monetize your hardware when you're not using it
• Support AI research and development
• Join a global network of compute providers

For Developers

• Test the network and understand how it works
• Contribute to development by running test nodes
• Debug issues and improve the system
• Build applications that use the network

For Community Members

• Learn about decentralized computing
• Support the project by providing infrastructure
• Help test new features and improvements
• Contribute to network health and reliability

🖥️ Hardware Requirements

Minimum Requirements

• CPU: 4+ cores (Intel i5/AMD Ryzen 5 or better)
• RAM: 8GB DDR4
• Storage: 50GB SSD
• Network: 10 Mbps upload/download
• OS: Linux (Ubuntu 20.04+), Windows 10+, or macOS 10.15+

Recommended for AI Workloads

• GPU: NVIDIA RTX 3060 or better (8GB+ VRAM)
• CPU: 8+ cores (Intel i7/AMD Ryzen 7 or better)
• RAM: 16GB+ DDR4
• Storage: 100GB+ NVMe SSD
• Network: 100 Mbps upload/download

Enterprise/Data Center

• GPU: Multiple NVIDIA A100, H100, or RTX 4090
• CPU: 16+ cores with high clock speeds
• RAM: 64GB+ ECC DDR4/DDR5
• Storage: 1TB+ NVMe SSD with high IOPS
• Network: 1 Gbps+ with low latency
• Cooling: Proper thermal management for sustained GPU workloads

🚀 Getting Started

Option 1: Desktop Application (Recommended)

The easiest way to run a worker node is using our cross-platform desktop application:

1. Download the App

   • Visit ciro.network/download
   • Download for your operating system (Windows, macOS, Linux)

2. Install and Setup

   # Extract and run the installer
   # Follow the guided setup process
   # Connect your wallet (Starknet)
   # Configure your hardware settings
   

3. Start Contributing

   • The app automatically detects your GPU
   • Configure your preferences and limits
   • Start earning CIRO tokens immediately

Option 2: Command Line (Advanced)

For developers and advanced users who want more control:

Prerequisites

# Install Rust (if not already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Install system dependencies (Ubuntu/Debian)
sudo apt update
sudo apt install -y build-essential pkg-config libssl-dev

# Install Docker (for containerized workloads)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

Build and Run

# Clone the repository
git clone https://github.com/ciro-network/ciro-network.git
cd ciro-network/rust-node

# Build the worker node
cargo build --release

# Create configuration file
cp environment.example .env
# Edit .env with your settings

# Run the worker node
cargo run --bin ciro-worker

⚙️ Configuration

Environment Variables

Create a .env file in your project directory:

# ===== Worker Node Configuration =====
WORKER_ID=worker-001
WORKER_NAME=My CIRO Worker
WORKER_GPU_COUNT=1
WORKER_GPU_MEMORY=8192  # 8GB in MB
WORKER_MAX_CONCURRENT_JOBS=3
WORKER_STAKE_AMOUNT=100000000000000000000  # 100 CIRO tokens

# ===== Blockchain Configuration =====
STARKNET_RPC_URL=https://alpha-sepolia.starknet.io
STARKNET_NETWORK=sepolia-testnet
STARKNET_ACCOUNT_ADDRESS=0x123...
STARKNET_PRIVATE_KEY=0x456...

# ===== P2P Network Configuration =====
P2P_LISTEN_ADDRESS=/ip4/0.0.0.0/tcp/4001
P2P_EXTERNAL_ADDRESS=/ip4/your-public-ip/tcp/4001

# ===== AI/ML Configuration =====
OLLAMA_HOST=http://localhost:11434
HUGGINGFACE_TOKEN=hf_your_token_here
COMPUTE_TIMEOUT=300
MAX_MEMORY_GB=8
MAX_GPU_MEMORY_GB=16

# ===== Monitoring Configuration =====
RUST_LOG=info

Hardware Configuration

GPU Settings

# Check your GPU capabilities
nvidia-smi  # For NVIDIA GPUs
rocm-smi   # For AMD GPUs

# Configure GPU memory limits
export CUDA_VISIBLE_DEVICES=0  # Use first GPU
export GPU_MEMORY_LIMIT=8192   # 8GB limit

System Optimization

# Enable performance mode (Ubuntu)
sudo cpupower frequency-set -g performance

# Optimize for GPU workloads
echo 'performance' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

# Increase file descriptor limits
echo '* soft nofile 65536' | sudo tee -a /etc/security/limits.conf
echo '* hard nofile 65536' | sudo tee -a /etc/security/limits.conf

🔧 Advanced Setup

Docker Deployment

For containerized deployment:

# Build the Docker image
docker build -t ciro-worker .

# Run with environment variables
docker run -d \
  --name ciro-worker \
  --gpus all \
  -p 4001:4001 \
  -v /var/lib/ciro:/data \
  --env-file .env \
  ciro-worker

Systemd Service (Linux)

Create a systemd service for automatic startup:

# Create service file
sudo tee /etc/systemd/system/ciro-worker.service << EOF
[Unit]
Description=CIRO Network Worker Node
After=network.target

[Service]
Type=simple
User=ciro
WorkingDirectory=/opt/ciro-worker
ExecStart=/opt/ciro-worker/ciro-worker
Restart=always
RestartSec=10
Environment=RUST_LOG=info

[Install]
WantedBy=multi-user.target
EOF

# Enable and start the service
sudo systemctl enable ciro-worker
sudo systemctl start ciro-worker

Monitoring with Prometheus

Set up monitoring for your worker node:

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'ciro-worker'
    static_configs:
      - targets: ['localhost:9090']
    metrics_path: '/metrics'

📊 Monitoring Your Node

Health Checks

Monitor your node's health:

# Check node status
curl http://localhost:8080/health

# View worker statistics
curl http://localhost:8080/workers/stats

# Check job completion rates
curl http://localhost:8080/jobs/stats

Performance Metrics

Track key performance indicators:

• GPU Utilization: Monitor GPU usage and temperature
• Job Completion Rate: Track successful vs failed jobs
• Earnings: Monitor CIRO token rewards
• Network Connectivity: Check P2P connection status
• System Resources: Monitor CPU, memory, and disk usage

Logs and Debugging

Enable detailed logging:

# Set log level
export RUST_LOG=debug

# View real-time logs
tail -f /var/log/ciro-worker.log

# Check for errors
grep ERROR /var/log/ciro-worker.log

🛠️ Troubleshooting

Common Issues

1. GPU Not Detected

# Check GPU drivers
nvidia-smi  # Should show your GPU

# Install NVIDIA drivers if needed
sudo apt install nvidia-driver-535

# Verify CUDA installation
nvcc --version

2. Network Connection Issues

# Check firewall settings
sudo ufw status

# Open required ports
sudo ufw allow 4001/tcp  # P2P networking
sudo ufw allow 8080/tcp  # API endpoint

# Test connectivity
curl -I https://alpha-sepolia.starknet.io

3. Blockchain Connection Problems

# Verify Starknet configuration
echo $STARKNET_RPC_URL
echo $STARKNET_ACCOUNT_ADDRESS

# Check account balance
curl -X POST $STARKNET_RPC_URL \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"starknet_getBalance","params":{"block_id":"latest","contract_address":"'$STARKNET_ACCOUNT_ADDRESS'"},"id":1}'

4. Performance Issues

# Monitor system resources
htop
nvidia-smi -l 1

# Check for memory leaks
valgrind --tool=memcheck ./ciro-worker

# Optimize for your hardware
# Adjust WORKER_MAX_CONCURRENT_JOBS based on your system

Getting Help

If you encounter issues:

1. Check the logs: Look for error messages in the logs
2. Search existing issues: Check our GitHub issues
3. Join our Discord: Get help from the community
4. Create a bug report: Use our bug report template

💰 Earning and Rewards

How Rewards Work

• Job Completion: Earn CIRO tokens for each completed job
• Quality Bonuses: Higher rewards for high-quality results
• Reliability Bonuses: Consistent workers earn more
• Staking Rewards: Stake CIRO tokens to earn additional rewards

Optimizing Earnings

• Maintain High Uptime: Keep your node running consistently
• Provide Quality Results: Ensure accurate and timely job completion
• Stake CIRO Tokens: Increase your earning potential
• Monitor Performance: Optimize your hardware configuration

Withdrawing Rewards

# Check your balance
curl http://localhost:8080/wallet/balance

# Withdraw to your wallet
curl -X POST http://localhost:8080/wallet/withdraw \
  -H "Content-Type: application/json" \
  -d '{"amount": "100000000000000000000"}'

🔒 Security Best Practices

Wallet Security

• Use a dedicated wallet for your worker node
• Keep private keys secure and never share them
• Use hardware wallets for large amounts
• Regular backups of your wallet configuration

System Security

• Keep software updated with the latest security patches
• Use strong passwords and enable 2FA where possible
• Monitor for suspicious activity in your logs
• Isolate your worker node on a separate network if possible

Network Security

• Configure firewalls to only allow necessary traffic
• Use VPN for additional security if needed
• Monitor network traffic for unusual patterns
• Regular security audits of your setup

🚀 Scaling Your Operation

Multiple Nodes

Run multiple worker nodes for increased earnings:

# Create separate configurations for each node
cp .env .env.worker-1
cp .env .env.worker-2

# Edit each configuration with unique settings
# WORKER_ID=worker-001
# WORKER_ID=worker-002

# Run multiple instances
cargo run --bin ciro-worker -- --config .env.worker-1 &
cargo run --bin ciro-worker -- --config .env.worker-2 &

Load Balancing

For high-performance setups:

# Use a load balancer for multiple GPUs
export CUDA_VISIBLE_DEVICES=0,1,2,3

# Configure job distribution
export WORKER_MAX_CONCURRENT_JOBS=12  # 3 jobs per GPU

Data Center Deployment

For enterprise-scale operations:

• Use container orchestration (Kubernetes, Docker Swarm)
• Implement monitoring (Prometheus, Grafana)
• Set up alerting for system issues
• Use dedicated hardware for optimal performance

📚 Next Steps

Ready to dive deeper? Check out these resources:

• Technical Overview - Understand the network architecture
• Smart Contracts - Learn about the blockchain integration
• Tokenomics - Understand the economic model
• Contributing Guide - Other ways to contribute
• Community Guidelines - Join our community

Thank you for helping build the future of decentralized computing! 🌟

Your worker node contributes to making AI computing accessible to everyone. Every job you complete helps researchers, developers, and organizations around the world.

Questions? Need help? Join our Discord or check our documentation.

Community Guidelines

Welcome to the Ciro Network community! 🌟

We're building something extraordinary together—a decentralized network that makes AI computing accessible to everyone. This community is the heart of our mission, and these guidelines help us create a space where everyone feels welcome, valued, and empowered to contribute.

🤝 Our Values

Inclusivity

We welcome contributors from all backgrounds, experiences, and perspectives. Diversity makes us stronger, and we're committed to creating an environment where everyone can thrive.

Respect

We treat each other with kindness, empathy, and respect. We value different viewpoints and approaches, even when we disagree.

Transparency

We believe in open communication and honest dialogue. We share our challenges, celebrate our successes, and learn from our mistakes together.

Collaboration

We succeed when we work together. We support each other's growth, share knowledge freely, and build on each other's ideas.

Impact

We're driven by the real-world impact of our work. Every contribution, no matter how small, helps make AI computing more accessible to people around the world.

💬 Communication Standards

Be Welcoming

• Greet newcomers warmly and help them feel included
• Use inclusive language that respects all identities
• Ask questions to understand different perspectives
• Celebrate contributions of all sizes and types

Be Clear and Constructive

• Explain your reasoning when sharing ideas or feedback
• Ask clarifying questions before making assumptions
• Provide context for your suggestions or concerns
• Focus on the work rather than the person

Be Patient and Supportive

• Remember that everyone learns at different paces
• Offer help when you see someone struggling
• Share resources and knowledge freely
• Encourage questions and curiosity

Be Professional

• Stay on topic in discussions
• Respect time zones and availability
• Use appropriate channels for different types of communication
• Follow platform-specific etiquette

🚫 What We Don't Tolerate

Harassment and Discrimination

We have zero tolerance for:

• Harassment of any kind (sexual, racial, religious, etc.)
• Discrimination based on identity or background
• Bullying or intimidation
• Hate speech or offensive language

Disruptive Behavior

We don't allow:

• Spam or off-topic content
• Trolling or inflammatory comments
• Personal attacks or name-calling
• Disrespectful or dismissive behavior

Unprofessional Conduct

We expect everyone to:

• Respect confidentiality when appropriate
• Follow security guidelines for sensitive information
• Maintain professional boundaries
• Report concerns to community moderators

🌍 Community Spaces

Discord Server

Our main community hub where you can:

• Chat with the team and other contributors
• Ask questions and get help
• Share ideas and feedback
• Join topic-specific channels (development, research, community, etc.)
• Participate in events and discussions

Guidelines for Discord:

• Use appropriate channels for your questions
• Be patient with response times
• Respect voice channel etiquette
• Use threads for longer discussions

GitHub Discussions

For technical discussions and project planning:

• Ask technical questions about the codebase
• Share ideas for new features
• Discuss architecture and design decisions
• Plan community events and initiatives

Guidelines for GitHub:

• Search existing discussions before posting
• Use clear, descriptive titles
• Tag relevant team members when needed
• Follow up on resolved discussions

Social Media

Stay connected and share our mission:

• Follow us on Twitter
• Share updates and achievements
• Engage with the community respectfully
• Represent the project positively

Meetups and Events

Join us in person or virtually:

• Local meetups in your area
• Virtual events and workshops
• Hackathons and coding sessions
• Conference presentations and panels

🤝 How to Contribute to the Community

For Newcomers

• Introduce yourself in the #introductions channel
• Ask questions - there are no stupid questions!
• Start small with simple contributions
• Find a mentor or buddy to help you get started

For Experienced Contributors

• Welcome newcomers and help them feel included
• Share your knowledge and experience
• Mentor others who are learning
• Lead by example with positive behavior

For Everyone

• Participate actively in discussions
• Share your ideas and feedback
• Help others when you can
• Celebrate successes and milestones

🔧 Technical Discussions

Code Reviews

When reviewing code:

• Be constructive and specific
• Focus on the code, not the person
• Explain your reasoning for suggestions
• Acknowledge good work and improvements
• Ask questions to understand the approach

Design Discussions

When discussing architecture or design:

• Consider multiple perspectives and approaches
• Weigh trade-offs honestly
• Focus on user needs and impact
• Be open to changing your mind
• Document decisions for future reference

Bug Reports and Issues

When reporting problems:

• Provide clear, detailed information
• Include steps to reproduce
• Be patient with the resolution process
• Follow up on your reports
• Thank people who help you

⚖️ Conflict Resolution

Addressing Issues

If you encounter a problem:

1. Talk directly to the person involved (if comfortable)
2. Use private messages for sensitive discussions
3. Contact moderators if the issue persists
4. Document the situation for reference

Mediation Process

When conflicts arise:

• Listen to all perspectives with an open mind
• Focus on the issue, not personalities
• Seek common ground and shared goals
• Find solutions that work for everyone
• Learn from the experience to prevent future issues

Escalation

If conflicts can't be resolved informally:

• Contact community moderators for assistance
• Provide specific details about the situation
• Be patient with the resolution process
• Respect the final decision of the moderation team

🎉 Recognition and Celebration

Acknowledging Contributions

We believe in recognizing and celebrating contributions:

• Thank people for their help and contributions
• Highlight great work in community channels
• Share success stories and achievements
• Nominate contributors for recognition

Community Milestones

We celebrate together:

• Project milestones and releases
• Individual achievements and growth
• Community events and meetups
• Positive impact stories

Contributor Spotlight

We regularly feature:

• New contributors and their first contributions
• Long-time members and their impact
• Special achievements and milestones
• Community leaders and mentors

🛡️ Safety and Security

Personal Information

• Respect privacy and don't share personal information
• Use appropriate channels for sensitive discussions
• Report privacy violations to moderators
• Be mindful of what you share publicly

Security Best Practices

• Follow security guidelines for the project
• Report security issues through proper channels
• Don't share sensitive information in public channels
• Use secure communication when needed

Mental Health and Well-being

• Take breaks when you need them
• Set healthy boundaries for your involvement
• Support others who may be struggling
• Seek help if you're experiencing difficulties

📚 Learning and Growth

Continuous Learning

We encourage:

• Asking questions and seeking knowledge
• Sharing what you learn with others
• Trying new things and taking risks
• Learning from mistakes and failures

Skill Development

We support:

• Mentorship and coaching relationships
• Skill-sharing sessions and workshops
• Learning resources and documentation
• Career development and growth opportunities

Feedback and Improvement

We value:

• Constructive feedback that helps us grow
• Regular reflection on our practices
• Continuous improvement of our processes
• Open dialogue about community needs

🚨 Reporting Issues

How to Report

If you experience or witness inappropriate behavior:

1. Document the incident with specific details
2. Contact moderators through appropriate channels
3. Provide context and any relevant information
4. Follow up if needed

What We Need

When reporting, please include:

• What happened (specific details)
• When it happened (date and time)
• Where it happened (which platform/channel)
• Who was involved (if known)
• How it made you feel (impact)

What Happens Next

After you report:

• We'll investigate the situation thoroughly
• We'll communicate with you about the process
• We'll take appropriate action based on our guidelines
• We'll follow up to ensure the issue is resolved

🌟 Community Leadership

Moderators

Our community moderators:

• Enforce guidelines fairly and consistently
• Help resolve conflicts and issues
• Support community growth and development
• Represent the community values and mission

Community Champions

We recognize community members who:

• Lead by example with positive behavior
• Help others and share knowledge
• Contribute consistently to the community
• Represent our values in their interactions

Getting Involved

Want to help lead the community?

• Start small by helping newcomers
• Share your expertise in your areas of knowledge
• Organize events or discussions
• Mentor others who are learning

📞 Getting Help

Community Support

Need help with:

• Technical questions → Ask in #help or #questions
• Community issues → Contact moderators
• Project questions → Use GitHub Discussions
• General support → Ask in #general

Emergency Contacts

For urgent issues:

• Security concerns → security@ciro.network
• Code of conduct violations → community@ciro.network
• Technical emergencies → dev@ciro.network

Resources

Additional resources:

• Contributing Guide - How to contribute
• Documentation - Project documentation
• GitHub Issues - Bug reports and feature requests
• Discord - Community chat

🔄 Guidelines Updates

Review Process

We regularly review and update these guidelines:

• Community feedback helps us improve
• Changing needs require updates
• New challenges need new approaches
• Growth requires adaptation

Suggestions

Have ideas for improving our community?

• Share your suggestions in #community-feedback
• Start discussions about community needs
• Propose changes to these guidelines
• Help implement improvements

🌟 Thank You

Thank you for being part of our community! Together, we're building something truly special—a decentralized network that makes AI computing accessible to everyone.

Your contributions, big and small, make a difference. Whether you're writing code, helping others, sharing ideas, or simply being a positive presence, you're helping us achieve our mission.

Questions about these guidelines? Want to suggest improvements? Reach out to our community moderators or start a discussion in our Discord.

Let's build the future of decentralized computing together! 🚀