Due Diligence Knowledge Base

A distributed AI compute routing layer that intelligently dispatches inference requests across local device GPUs, a peer mesh of contributed nodes, and cloud providers — choosing the cheapest capable route for every request.

MeshInfer.AI is an inference routing platform. When a developer sends an LLM or model inference request through the API, the Coordinator evaluates device capabilities, privacy constraints, latency tolerance, and cost preference — then routes the request to the cheapest execution target that can satisfy it:

The platform is not a model host — it is a routing and settlement layer that sits between the application and whatever compute happens to be available and cheapest. It is part of a broader ecosystem (DOSFI) that includes social inference, credit scoring, streaming, navigation, and trading — all built on the same mesh-native routing fabric.

Cloud inference is expensive and getting more so. Most devices already have capable GPUs sitting idle. The gap between what people pay cloud providers and what their own hardware could do is the opportunity.

The economics of LLM inference are structurally inverted. A consumer GPU that cost $500 can run a 1B–3B parameter model locally at near-zero marginal cost, yet developers routinely pay cloud providers $0.15–$15 per million tokens for the same output. The waste compounds:

• Cloud providers charge for idle capacity the customer already owns.
• Latency-sensitive applications pay a network round-trip tax they don't need.
• Privacy-sensitive workloads (PHI, financial data) are forced to cloud for lack of a trusted local path.
• There is no marketplace where idle consumer GPUs can be productively monetized.

SaaS subscriptions for the routing platform, margin on cloud fallback traffic, and a settlement fee on DIU (Vital) earned by mesh node contributors.

The subscription tiers gate access to the routing API, dashboard analytics, and advanced features (A/B testing, canary deployments, custom routing policies). Usage overages are metered and billed through Stripe. The mesh economy (DIU) creates a secondary flywheel: contributors earn for providing capacity, the platform takes a settlement cut, and end-users get cheaper inference.

The moat is not any single algorithm — it is the integration of capability-based routing, a privacy-tiered execution model, post-quantum identity, a working settlement economy, and a live, audited node fleet.

The components are individually replicable. The integration is not. Specifically:

The DIU (Distributed Intelligence Unit, "Vital") economy is funded by the value it replaces — cloud inference spend that is avoided when a request routes to local or mesh execution.

DIU is not a pre-mined token or an ICO instrument. It is an internal accounting unit that represents compute contributed to or consumed from the mesh. The funding loop:

1. A developer pays a subscription + usage fees in USD (via Stripe).
2. A request routes to a mesh node instead of cloud, avoiding ~$X of cloud cost.
3. The node operator earns DIU proportional to the compute provided (tokens, latency, reliability).
4. The developer pays less than cloud retail; the platform retains a settlement fee; the node operator accumulates DIU.
5. DIU can be settled to USD via the payout system (PayoutRequest → processPayout).

Earning categories are structured across five dimensions: participation (telemetry, uptime), inference (executing requests), coverage (regional density), service (routing, coordination), and governance (identity verification, compliance). Each category has tier-based multipliers (Bronze → Diamond) that scale rewards with sustained contribution.

Five risk vectors are addressed structurally: execution failure (honest fallback), node dishonesty (PoI attestation + reputation), privacy exposure (tiered routing), quantum threat (PQC signatures), and economic manipulation (tier-gated multipliers).

Governance is layered: the platform operator controls the Coordinator and routing policies; mesh policies are configurable per-deployment; the DOSFI identity fabric controls node and user identity; no single party controls the node fleet.

There is no DAO, no token voting, and no governance theater. Governance is operational: policies are entities, enforcement is code, and every decision is logged. The Unifying Theory (11 components) provides the architectural constitution that all ecosystem systems inherit.

The routing layer scales horizontally by design. The constraint is not software — it is physical GPU hardware. Verified capacity today is 1 concurrent real node; the architecture supports N, but each node requires a real WebGPU-capable device.

The honest answer, backed by audited data:

The dispatch layer is verified functional: capability-based routing, heartbeat freshness gating, and honest cloud fallback all work. What does not exist yet is a fleet of physical GPU-equipped nodes at scale. Scaling from 1 to 100 nodes is a hardware provisioning problem, not a software problem — and the platform is honest about that rather than simulating nodes to inflate the numbers.

Three forces converged in 2024–2026: WebGPU shipped in all major browsers, small open-weight models (1B–3B) became genuinely useful, and cloud inference costs remained stubbornly high. The routing layer is the missing connective tissue.

Runtime-verified cryptography, audited routing logs, a live node fleet with real heartbeats, a working Stripe billing pipeline, and a transparent testing harness that anyone can run.