A distributed AI execution platform that chooses the best path.
MeshInfer reduces inference cost, improves privacy, and automatically routes every request to the optimal execution environment — local device, peer node, or cloud — based on cost, latency, and privacy constraints.
Turn Idle Silicon into Passive Revenue
Your H100s shouldn't be paperweights between training runs.
The Problem
You spent $30,000+ per H100 (or $2–4/hr renting them out). Yet most enterprise GPUs sit at <20% utilization:
- ·Training runs finish and leave racks idle for weeks.
- ·Off-peak hours (nights/weekends) burn electricity with no ROI.
- ·Renting out spare capacity means building a complex inference stack, managing billing, and competing with AWS/Azure.
Result: Millions of dollars of silicon depreciating in your server room, generating zero revenue.
The Solution
MeshInfer's Lending Node – a lightweight runtime that connects your GPUs to our distributed inference fabric.
Install the node. We route real inference traffic to your hardware.
We handle routing, load balancing, authentication, and payment settlement.
We route low-latency, privacy-sensitive, and edge-adjacent workloads that hyperscalers can't serve efficiently.
Supported Hardware
The lending node runs on any GPU with a WebGPU-compatible or CUDA runtime — from datacenter H100s to consumer cards and integrated graphics. Every GPU earns.
- H100 80GB
- A100 80GB
- A100 40GB
- V100 32GB
- T4 16GB
- RTX 4090 (24GB)
- RTX 4080 (16GB)
- RTX 4070 Ti (12GB)
- RTX 4070 (12GB)
- RTX 4060 Ti (8GB)
- RTX 4060 (8GB)
- RTX 3090 (24GB)
- RTX 3080 Ti (12GB)
- RTX 3080 (10GB)
- RTX 3070 Ti (8GB)
- RTX 3070 (8GB)
- RTX 3060 Ti (8GB)
- RTX 3060 (12GB)
- RTX 3050 (8GB)
- RTX 2080 Ti (11GB)
- RTX 2080 (8GB)
- RTX 2070 (8GB)
- RTX 2060 (6GB)
- GTX 1660 Ti (6GB)
- GTX 1660 (6GB)
- GTX 1650 (4GB)
- GTX 1080 Ti (11GB)
- GTX 1080 (8GB)
- GTX 1070 (8GB)
- GTX 1060 (6GB)
- GTX 1050 Ti (4GB)
- RX 7900 (24GB)
- RX 6800 (16GB)
- RX 6700 XT (12GB)
- RX 6600 (8GB)
- RX 5700 (8GB)
- RX 5600 (6GB)
- M3 Max
- M3 Pro
- M3
- M2 Max
- M2 Pro
- M2
- M1 Max
- M1 Pro
- M1
- Iris Xe (4GB)
- UHD Graphics (2GB)
- HD Graphics (1.5GB)
Don't see your GPU? The node auto-detects VRAM and routes models that fit. Unknown GPUs fall back to a conservative RAM-based estimate — they still earn, just with smaller models.
How It Works
Our containerized node on your idle GPU cluster — any supported hardware from the list above.
We profile your hardware's throughput and latency.
MeshInfer dynamically routes inference requests to your node based on:
- ·Proximity to the end user (120ms mesh average)
- ·Current load (we never overload your node)
- ·Price competitiveness (you set a minimum floor price)
The Economics
| Cloud Pricing (Benchmark) | Mesh Lender Payout (per inference) | Your Margin vs. Idle |
|---|---|---|
| $0.000249 (GPT-5 mini proxy) | $0.00008 – $0.00012 | 100% (idle → revenue) |
Revenue projection per GPU (H100-class) @ 40% utilization:
| Daily Inferences | Payout per Inf | Daily Revenue | Monthly Revenue |
|---|---|---|---|
| 500,000 | $0.00010 | $50 | $1,500 |
| 1,000,000 | $0.00010 | $100 | $3,000 |
| 5,000,000 | $0.00010 | $500 | $15,000 |
The longer your node stays online in a single session, the higher your per-task payout multiplier:
Plus: every 100 consecutive heartbeats awards a bonus DIU. Keep your node online to maximize earnings.
Utilization depends on your node's performance and availability. Our routing engine fills your capacity organically—no minimums.
Why This Beats Traditional GPU Rentals
| AWS/Azure Rental | MeshInfer Lending | |
|---|---|---|
| Setup | Full inference stack + networking | One container, 15-min install |
| Payout | Fixed hourly rate (idle = no income) | Per-inference payout (active = income) |
| Traffic | You must attract customers | We feed you traffic from our active mesh nodes |
| Overhead | Billing, support, scaling | We handle everything |
Live Proof
Our mesh currently routes 799 inferences with:
Your GPU joins this existing fabric. No bootstrapping. No cold start.
The Offer: 30-Day Pilot
- 1You connect one rack (8 GPUs) to our network.
- 2We route live production traffic to it for 30 days.
- 3You get a dashboard showing total inferences served, revenue generated, and utilization % over time.
We're confident enough in the fabric's traffic density that the pilot is risk-free to try — if your node earns nothing, you've lost nothing but idle cycles that were already idle.
Ready to Monetize Idle Silicon?
Reply to this deck. We'll schedule a 15-min tech sync to get your node online.
Your GPUs are sitting there anyway. Let's make them work.
The premise
Every AI-powered web app today runs every token through a hyperscaler. That's wasteful. The average SaaS user's laptop has 16GB of RAM, an M-series neural engine or discrete GPU, and sits idle 97% of the day. A 3B parameter model at Q4 quantization now fits in 1.8GB and runs at 40+ tokens/sec in the browser via WebGPU.
MeshInfer.AI is the missing infrastructure layer: a drop-in SDK + coordinator that routes each inference request to the optimal compute target — local device, a peer Node in the mesh, or a cloud LLM — based on model size, latency budget, cost preference, and Privacy Tier.
Core value
Push 40–80% of traffic to user-owned silicon. Pay cloud rates only for overflow.
Sub-100ms round trips when the model runs in the same tab as the user.
Prompts and embeddings never leave the device for local-eligible routes.
Works offline, on trains, on spotty 3G. Graceful degradation, not failure.
Why the mesh runs on open-source
The mesh exists because of open-source models. You can't run GPT-4o on a browser tab or a consumer GPU — but you can run Llama-3.2-1B, Phi-3.5-mini, and Qwen-2.5 on exactly that hardware. That single fact is what makes distributed inference economically viable.
Every time a new open-source model drops — better quality, smaller footprint, faster decode — your mesh gets better. No infrastructure change, no renegotiation, no new vendor contract. The improvement is automatic.
What runs where
1B–4B quantized models (Llama-3.2-1B, Phi-3.5-mini) run in-browser via WebGPU or on-device via CoreML/NNAPI. Zero network, zero per-token cost.
3B–70B models run on contributor GPUs — consumer cards (RTX 3060–4090), datacenter H100s, Apple Silicon. Routed by capability and proximity.
Proprietary cloud models (GPT-5 mini) serve only when no open-source model meets the quality bar. The router promotes hard requests up; easy ones stay on the mesh.
The quality gap is closing
Open-source models are no longer a compromise. On the benchmarks page, Phi-3.5-mini trails GPT-4o-mini by 5–13 points on MMLU and IFEval — and the gap halves with every model generation. But the cost gap is permanent: a mesh inference costs fractions of a cent; a cloud API call costs full retail.
Routing implication: The router promotes hard requests (detected via prompt complexity + token budget) to cloud automatically. Easy requests — ~70% of real SaaS traffic — stay on open-source models with no perceptible quality drop. See the quality parity data →
The flywheel
Each new open-source release (Llama 4, Phi-4, Qwen-3) raises quality without any mesh change. The router just routes to it.
Quantization (Q4, Q3, Q2) and distillation pack larger models into smaller VRAM. More devices become capable nodes.
Open-source models enable local-only and no-cloud policies. Proprietary APIs structurally cannot — your data must leave the device.
No per-token pricing, no rate limits, no model deprecation risk. You own the model weights; the mesh owns the routing.
How it scales across organizations and jurisdictions
The execution layer is only the start. These five structural mechanisms let the system grow beyond a single mesh — across organizations, regions, and legal jurisdictions.
Automated rules enforce compliance, quality, and fair access — no central operator required.
Independent meshes interconnect via verified handshakes, pooling capacity across regions and organizations.
Data residency, encryption, and PHI-local-only constraints are enforced per region and per workload.
Compute capacity and inference credits are listed, discovered, and settled across meshes.
A metered, compute-backed economic model balances supply and demand — keeping the system self-sustaining.
Who it's for
- AI-first SaaS. Cursor-likes, Notion-AI-likes, copilots burning $40k+/mo on OpenAI.
- Consumer apps. Chat, writing, translation, summarization at global scale.
- Regulated industries. Healthcare, legal, finance — where prompts cannot leave the device.
- Edge & offline. Field apps, airline apps, developing-market apps.
The Mesh-Native Ecosystem
MeshInfer.AI is one layer of a unified five-platform stack. Together they form the Distributed Intelligence Stack — a complete system for building, running, and settling intelligence across the global mesh.
Settles DIU (Distributed Intelligence Unit) issuance and spend in hourly epochs. Receives metering events from MeshInfer, verifies integrity, and commits final wallet credits. The settlement ledger of the inference fabric.
The distributed operating system for mesh-native applications. Provides the runtime, scheduler, identity layer, privacy model, and DOSFI compute protocol. Applications run on DOSFI; inference flows through MeshInfer.
Routes and executes intelligence across devices — local, mesh peer, or cloud — with privacy-first routing, PQC security, and real-time cost optimization.
Developer onboarding for the Distributed Intelligence Stack. Courses and hands-on labs covering MeshInfer SDK integration, inference routing, DIU metering, and building production mesh-native applications.
Enterprise certification for distributed inference engineering. Architect-tier curriculum covering MeshInfer architecture, 20-node mesh operations, DIU economics, and production-scale deployment.