How we calculate our indexes and scores

The DeAI Dashboard tracks decentralized AI and compute networks using only public data — token markets, on-chain stats, and each network's own inventory APIs. Data is collected automatically every ~10 minutes and stored as time series. Three of the headline figures are computed by us from a shared GPU reference table; the rest are reported numbers we normalize and chart.

See the full list of data sources →

The GPU reference table

Every compute metric starts from one reference table of GPU models. For each model we store three values:

• FP16 dense TFLOPS — raw half-precision tensor compute (dense, no sparsity).
• B200 Index coefficient — the GPU's AI throughput relative to an NVIDIA B200 (B200 = 1.00).
• Qwen 3.6-35B throughput — tokens/second that GPU can serve running a mid-sized open LLM (blank if the GPU lacks the VRAM to run it at all).

Networks report GPU names in many spellings (NVIDIA A100-SXM4-80GB | 80GB, pro_6000, H100 80GB HBM3, …). A fuzzy matcher normalizes vendor prefixes, separators, memory units, and interconnect suffixes so each reported name resolves to the right reference row. Unknown models contribute zero rather than being guessed.

B200 Index normalized compute

The B200 Index expresses a network's whole GPU fleet as an equivalent count of NVIDIA B200 cards. It's a hardware-class-aware alternative to a raw GPU count — 1,000 H100s and 1,000 RTX 4090s are very different fleets.

B200 Index = Σ (gpu_count × B200_coefficient)   for every GPU model in inventory

Each coefficient is that GPU's AI tensor throughput divided by the B200's (e.g. H100 = 0.44, H200 = 0.44, A100 80GB = 0.14, RTX 4090 = 0.07). When a network reports only an aggregate compute figure instead of a per-model breakdown, we fall back to dividing its reported FP16 tensor TFLOPS by the B200 reference (2,250 TFLOPS).

Throughput tok/day

Where the B200 Index measures raw hardware, Throughput estimates useful AI work: the theoretical maximum tokens/day the network could serve running Qwen 3.6-35B, a mid-sized open model needing ~70 GB of VRAM.

Throughput = Σ (gpu_count × Qwen_throughput) × 86,400   for GPUs that can run the model

Per-GPU throughput is measured in tokens/second; the per-second sum is multiplied by 86,400 (seconds in a day) for display. Large totals are abbreviated with M (millions), B (billions), and T (trillions).

GPUs that can't load the model (consumer cards, A100 40GB, T4, L40S, etc.) contribute zero, so this figure naturally filters a fleet down to its serious inference-capable hardware. Throughput values are theoretical peaks and don't account for utilization.

Market metrics

Price, market cap, 24h volume, and supply come from public market APIs (CoinPaprika, CoinMarketCap, CoinGecko depending on the token). Day-over-day deltas and sparklines are computed from our stored daily history (latest value vs. the previous day).

Community Score 0–100 composite

The Community Score rates how socially active and visible a network is across its community and developer channels. It folds multiple raw metrics from Discord, X, and GitHub into a single weighted 0–100 number, so a network that is small but lively can still rank ahead of a large-but-dead one. The underlying inputs come from each project's own public endpoints (Discord presence, GitHub repos) and a community-metrics provider for X.

The components split across three channels, and their weights sum to 1:

• Discord (weight 0.35) — total members, peak online presence over a rolling 24 hours, and activity rate (online ÷ members).
• X (weight 0.25) — average views per post, average engagements per post, and engagement rate (engagements ÷ views). Follower count is collected and shown but carries zero weight: followers are easy to inflate with bots, so they're a weak signal.
• GitHub (weight 0.40) — stars, commits in the last 30 days, and contributors, summed across the project's source repos.

Every component is scored the same way. The raw value is divided by the field maximum for that metric — so the leader on each metric scores full marks — clamped to 1, then raised to the power 0.35 before being weighted and rescaled onto its slice of 100:

component = weight × 100 × min(raw ÷ field_max, 1) ^ 0.35

The 0.35 power curve is deliberately concave: it lifts small values and compresses large ones, rewarding networks that are present and active rather than simply the biggest. (Discord activity rate is already a bounded ratio, so it's scaled linearly without the curve.) Summing all the weighted components gives the final 0–100 score.

Because each cap is the current field maximum, the Community Score is a relative ranking within the tracked set, not an absolute value comparable across time — a network's score can shift when another network's metrics change. A component with missing or non-positive data contributes zero rather than being guessed, and weights are not renormalized.

Compared to centralized labs

To give scale, we compare DeAI totals against published centralized-lab figures: aggregate throughput vs. OpenAI's reported API throughput, total market cap vs. OpenAI's valuation, and total B200 Index vs. xAI's Colossus cluster (~1M H100s ≈ 440k B200 Index). These are directional reference points, not like-for-like measurements.

Data freshness & caveats

• Figures refresh on a ~10-minute collection cycle; stale values are flagged.
• Some networks expose only aggregate or rentable-at-the-moment capacity rather than full fleet size — those are noted inline and may be excluded from cross-network totals.
• Throughput and TFLOPS values are theoretical peaks and ignore real-world utilization.