io.net (GPU Network) Integration
The standard problem with blockchain ML infrastructure is that centralized GPU providers (AWS, GCP) offer predictable latency and SLA but completely break the principle of permissionless access to computing. We face this every day when clients want to reduce costs while maintaining decentralization. io.net solves this through a DePIN model—a decentralized network of ~200K GPUs aggregated from data centers, mining farms, and gaming PCs. The integration challenge is not just calling a REST API but building a reliable pipeline that accounts for the specifics of decentralized computing: variable latency, worker failures, stochastic task distribution. We design such a system turnkey, ensuring stability and savings.
Integration Architecture with io.net
io.net provides two main interaction methods: IO Cloud API for managed clusters and IOG (IO Compute) for direct access to individual GPU workers. For production systems, the former with clusters is preferred.
Cluster Lifecycle
A typical flow looks like this:
POST /clusters → create cluster with GPU requirements GET /clusters/{id} → polling status (PROVISIONING → READY) POST /clusters/{id}/jobs → launch tasks GET /jobs/{job_id} → monitor execution DELETE /clusters/{id} → release resources A critical aspect is the provisioning strategy: io.net does not guarantee resource allocation time—depending on network load and GPU requirements, it can take from 2 minutes to 30+. Any integration must be built on an asynchronous model with webhook notifications or polling with exponential backoff, not synchronous calls with timeouts.
Cluster Specification
When creating a cluster, specify requirements:
{ "cluster_name": "inference-cluster-prod", "num_gpus": 8, "gpu_model": "NVIDIA_3090", "min_vcpus": 16, "min_ram": 64, "locations": ["US", "EU"], "compliance": ["GDPR"], "duration_hours": 4 } The gpu_model field is one of the most important. For LLM inference (LLaMA 3, Mistral), RTX 3090/4090 with 24GB VRAM is enough. For training or fine-tuning, A100/H100 with NVLink is needed. Mismatching GPU model to task is the main source of inefficient spending in io.net.
Why io.net is Better Than Cloud Providers?
Cost savings on inference can reach 80% compared to AWS SageMaker with comparable throughput. For periodic tasks (NFT generation, ZK-proofs), you don't need to reserve instances—pay only for actual usage. However, decentralization requires compensating for reliability: we incorporate checkpointing and retry mechanisms so that a worker loss does not reset progress.
How to Ensure Reliable Computing on a Decentralized GPU Network?
A decentralized network is inherently less predictable than managed cloud. In practice this means:
- A worker may disconnect mid-task (node lost connectivity, operator removed machine)
- GPUs may have varying performance—one cluster slot might be faster than another
- Network latency between workers in a cluster is not guaranteed—critical for tasks with allreduce (distributed training)
Retry and Checkpointing Pattern
For long tasks, a checkpoint mechanism is mandatory. If a 6-hour training task crashes at hour 5, without checkpoints it restarts from scratch:
class IONetJobManager: def __init__(self, api_key: str, checkpoint_storage: str): self.client = IONetClient(api_key) self.storage = CheckpointStorage(checkpoint_storage) # S3/IPFS def submit_with_retry(self, job_config: dict, max_retries: int = 3): last_checkpoint = self.storage.get_latest_checkpoint(job_config["job_id"]) if last_checkpoint: job_config["resume_from"] = last_checkpoint for attempt in range(max_retries): try: job = self.client.submit_job(job_config) return self._monitor_with_checkpointing(job) except WorkerFailureError as e: if attempt == max_retries - 1: raise wait_time = 2 ** attempt * 30 # 30s, 60s, 120s time.sleep(wait_time) Monitoring via On-Chain Events
io.net uses Solana for settlements and verification—this enables monitoring on top of on-chain events, not just REST API. Worker accounts update on status changes, and WebSocket subscription via @solana/web3.js (connection.onAccountChange) provides lower notification latency than API polling.
Payment via $IO Token
Payments in io.net are made with the $IO token (SPL-token on Solana). For automated systems, this necessitates on-chain balance management:
| Aspect | Solution |
|---|---|
| Balance top-up | Programmatic swap via Jupiter Aggregator or direct purchase |
| Spend control | Set max_spend limit on cluster creation |
| Refunds | Automatic on DELETE /clusters/{id} |
| Currency risk | Hedging via perpetuals on Drift Protocol |
For enterprise clients, io.net offers stablecoin settlements via a separate enterprise plan—this eliminates $IO volatility concerns.
Typical Use Cases
Inference-as-a-Service: Deploy a model on an io.net cluster and expose your own API on top. Savings compared to AWS SageMaker: 60–80% with comparable throughput.
Federated Learning: io.net supports isolated clusters with geographic compliance constraints—enabling federated learning pipelines where data does not leave the jurisdiction.
Burst Computing for Web3 Projects: On-chain games, AI content generation for NFTs, ZK-proof verification—tasks that need GPUs only periodically. io.net lets you pay only for used time without reserving capacity.
What's Included in the Integration
| Stage | Description |
|---|---|
| Analysis | Audit of current infrastructure, GPU configuration selection |
| Design | Development of asynchronous architecture with checkpointing and retry |
| Implementation | io.net API integration, cluster setup, $IO balance monitoring |
| Testing | Load testing, failure scenarios, SLA verification |
| Documentation | API description, operation instructions, runbook |
| Support | 3 months post-launch support, training for your team |
Methodology based on years of experience with decentralized computing.
Timeline and How to Start
We assess the project in 2–3 business days. Basic scenario integration takes 2 to 4 weeks. Complex projects with custom pipelines—up to 8 weeks.
We work with clients who have 5+ years of blockchain development experience and have completed over 50 projects. Contact us for an estimate—we'll send architecture examples and answer your questions.