DePIN Intelligence — verifiable supply data with a receipt on every number.
Kairos Signal is a verifiable DePIN data layer. We carry live telemetry for 457 symbols — 328 DePIN networks plus 129 Bittensor subnets as separate series — 297 of the networks first-party, read from the project's own endpoint or chain — out of 800 networks cataloged. That is 10,642 live series updating continuously (measured 2026-08-30). Every value ships with its source, an as_of timestamp, and a verify_url pointing to the upstream you can check yourself right now. Each daily batch is Merkle-rooted and anchored to Bitcoin. In a world drowning in AI slop and made-up numbers, we bring receipts.
Raw feeds are the input. The brief is the judgment: which networks are building capacity faster than demand absorbs it, whose published dashboard has quietly stopped updating, how much of each token's reported supply we can independently confirm on-chain, and where exchange balances just moved. Every line carries its source, its as-of time and a link to check it yourself.
This is how we caught Akash's own API serving 30.5% GPU utilisation while the measured figure was 55.8%. Read the latest brief →
API access is granted on approval. Every value carries its source + as_of + a verify_url to the upstream; each daily batch is Merkle-rooted and anchored to Bitcoin via OpenTimestamps.
Every value carries a receipt
The DePIN data surface is provenance-stamped values across 457 symbols — 328 networks plus 129 subnets — with live data (as of 2026-08-27), and every single one ships with its source, an as_of timestamp, and a verify_url to the upstream that produced it. Don't take our word for any number — click through and check it at the source.
{
"symbol": "AKT",
"metric": "circulating_supply",
"value": 383502056.718427,
"unit": "tokens",
"source": "CoinGecko /coins/markets",
"verify_url": "coingecko.com/en/coins/akash-network",
"as_of": "2026-08-09T17:15:20Z"
}Open the verify_url and read Akash's circulating supply at the source. If it doesn't match, we're wrong — and you'll know in one click. That is the entire product philosophy: irresistible because it's checkable.
The exact upstream endpoint behind the value — CoinGecko /coins/markets, DefiLlama /overview/fees, or a network's own API. No blended, un-attributable aggregates.
A live link to that upstream so you can confirm the number yourself this second. 100% of the 11,061 live series carry one.
The timestamp the value was read — staleness is on the record, not hidden. 10,057 of 10,641 live series were refreshed in the last 24 hours (measured 2026-08-27).
Where a network publishes no free feed, we name it in the coverage map instead of inventing a number.
Bitcoin-anchored provenance
The verify_url proves each number is real at the source. The Bitcoin anchor proves we didn't quietly change it afterward. Every value in today's batch is hashed into a Merkle tree; the root is submitted to 4 independent OpenTimestamps calendars and anchored to the Bitcoin blockchain. Once the timestamp confirms, the exact contents of the day's dataset are pinned to a point in Bitcoin's history that no one — including us — can backdate. A public per-value inclusion-proof endpoint ships with the API.
Not one number per network — dozens
Beyond market and revenue facts, 296 networks carry first-party telemetry read straight from each project's own API and chain (3,773 first-party series, measured 2026-08-27): node counts, committed CPU/GPU, storage, leases, staking, coverage. Here is the live metric breadth, measured from ClickHouse on 2026-08-26.
| Network | Symbol | Category | Live Metrics |
|---|---|---|---|
| Mysterium | MSN | VPN / Bandwidth | |
| Akash | AKT | Cloud Compute | |
| io.net | IO | GPU Compute | |
| ThreeFold | TFT | Compute / Storage | |
| Storj | STORJ | Storage | |
| WeatherXM | WXM | Weather Sensors | |
| Titan | TITAN | Storage / CDN | |
| Grass | GRASS | Bandwidth / Data | |
| Aleph.im | ALEPH | Compute / Storage | |
| Flux | FLUX | Compute | |
| Golem | GLM | Compute | |
| Chirp | CHIRP | Wireless / IoT | |
| Geodnet | GEOD | GNSS / Positioning | |
| Roam | ROAM | Wireless / WiFi | |
| Livepeer | LPT | Video Transcoding | |
| Filecoin | FIL | Storage | |
| Helium | HNT | Wireless | |
| Aethir | ATH | GPU Compute |
…and more networks in the deep-telemetry layer. Every metric is read from the network's own API/chain and carries its own source and timestamp. Sample metrics for Akash: ACTIVE_CPU, ACTIVE_GPU, ACTIVE_STORAGE, ACTIVE_LEASES, BONDED_TOKENS, STAKING_APR, REV_24H.
Coverage is a map, not a marketing number. 800 networks are cataloged (as of 2026-08-26), including the ones we don't yet cover — where a project publishes no free feed, the catalog says so rather than filling the gap with a guess.
DePIN Telemetry, Right Now
Coverage measured live from ClickHouse on 2026-08-27 — 457 symbols with data in the trailing 7 days (328 networks + 129 Bittensor subnets).
How Data Becomes Signals
Raw market data, public records, and blockchain telemetry are processed through the 63-layer ByteDAG to produce statistical signals.
Data Ingestion
Continuous collection of market ticks, weather data, energy grid status, county assessor filings, and DePIN blockchain telemetry.
Feature Extraction
Raw data is normalized and embedded into high-dimensional feature vectors — market-state, network telemetry, and regime descriptors, computed causally with no look-ahead.
63-Layer Forward Pass
The ByteDAG Neural SDE runs a 63-layer forward pass, computing neural SDE dynamics, gauge field geometry, and regime classification.
Signal Output + Hash
Classified signals are written to ClickHouse and hashed to a SHA-256 chain — an internal integrity ledger. Public verification and external anchoring are on the roadmap, not yet live.
The DePIN layer runs on a live world-data estate
Kairos is not just a crypto API. Underneath sits a telemetry estate ingesting markets, weather, seismic activity, power grids, rail, marine and space weather around the clock — the context layer DePIN numbers get judged against. The figures below are queried live from the estate itself.
The world layer now watches physical infrastructure directly: 4,148 AIS-tracked vessels across 2 national receiver networks, 26 satellite constellations, 437 military aircraft airborne at the latest sweep, 122 active US airspace restrictions (TFRs), and 29 days of GPS-interference history — all measured 2026-08-24.
Refreshed live from the estate at page load (fallback figures measured 2026-08-24) — verify the raw response yourself at /v1/world.
Where every number comes from
Not all first-party — and we label which is which. Each source is named on every value, so you always know exactly what you're trusting.
First-Party Network Telemetry
Node counts, committed CPU/GPU, storage, leases, staking and coverage read straight from each network's own API and chain — including Akash Console, WeatherXM stations and Flux nodes. The deep-telemetry layer: 296 networks, 3,773 first-party series (as of 2026-08-27).
CoinGecko — Market Facts
Price, market cap, circulating / total / max supply and fully-diluted valuation for 379 networks (as of 2026-08-27). Every value's verify_url links to the exact CoinGecko coin page, so you can confirm it at the source.
DefiLlama — Revenue & TVL
Protocol fees (24h / 7d / 30d) and TVL read from DefiLlama's public endpoints, each linked back to the DefiLlama page or api.llama.fi so the figure is checkable upstream.
GitHub — Dev Activity
Repository signals such as stars and open issues, pulled from GitHub for the projects that publish them. A live read on developer momentum, attributed to the exact repo.
Security
How signal integrity is ensured through cryptographic hashing and transparent logging.
Every signal, prediction, and hash is logged to an append-only ClickHouse ledger (immutable MergeTree storage, internal — not externally anchored yet) for full auditability. Infrastructure is self-hosted with transparent logging.
Every classified signal is hashed and chained, recording when each prediction was made and what was predicted, and making silent after-the-fact edits detectable internally. The chain records order and integrity — it does not establish that predictions were correct or profitable.
Three Products, One Stack
Kairos runs three products on one owned-hardware stack: a verifiable DePIN data API, statistical market signals from the ByteDAG Neural SDE, and GPU compute. The DePIN data is collected and provenance-stamped — it is measured telemetry, not model output.
Statistical Signal API
Access the 63-layer ByteDAG forward pass output for 47 crypto perpetual markets. Currently free while the model is in beta — we will not charge for this until it demonstrably beats free baselines out-of-sample.
DePIN Intelligence API
Live supply, revenue and market telemetry for 457 DePIN networks — 11,061 live series, 383 networks with first-party or chain-direct feeds, out of 800 cataloged (as of 2026-08-26). Every value carries source + as_of + a verify_url. API access on approval. Tiers: Design Partner $199/mo, Pro $499/mo, Enterprise $2,000+/mo.
Become a $199/mo Design Partner →GPU Compute API
68+ models served via a single API, $0.002/1K input · $0.004/1K output tokens. Self-hosted on owned hardware with transparent logging.
What You Can Build
Three areas where the ByteDAG signal pipeline provides useful data.
Crypto Market Signals
The ByteDAG Neural SDE generates directional signals for 47 crypto perpetual markets. Every signal is hashed into a SHA-256 chain in an internal integrity ledger; public verification and external anchoring are on the roadmap, not yet live.- 47 assets
- 63-layer neural SDE forward pass
- SHA-256 hash-chained signal ledger (internal)
DePIN Data Analysis
Public blockchain telemetry from Helium, DIMO, and Hivemapper (public data, not operated by us) cross-referenced with other data sources for infrastructure analysis.
- Helium, DIMO, Hivemapper public data
- Node telemetry correlation analysis
- Geographic coverage mapping
DePIN Provenance & Trust
Every value in the DePIN API carries source + as_of + a public verify-yourself URL. Where a network publishes no free feed, it's named as such — no invented numbers. The clean-epoch audit deleted fabricated series — only post-2026-08-06 data ships.
- 457 networks + 129 subnets · 11,061 provenance-stamped live series
- Per-metric provenance on every field
- Clean-epoch: fabricated series deleted, not shipped
Sample API Response
Every API response includes signal metadata and a SHA-256 chain hash. The block below is an illustrative response shape with example values — not live output; the confidence field is a placeholder and no confidence figure is validated out-of-sample.
{
"signal_id": "sig_2026_06_27_1200_az",
"timestamp": "2026-06-27T12:00:04Z",
"dag_layers_traversed": 63,
"state_dim": 256,
"classification": "TREND_BULL",
"confidence": 0.NN, // illustrative placeholder — not a validated figure
"asset": "BTC/USD",
"direction": "LONG",
"sha256_chain": "a1b2c3d4...",
"provenance": {
"dag_layers": 63,
"manifold_dim": 32,
}
}What You Get
Every signal links to the previous via SHA-256. Tamper-evident internally (append-only, hash-chained) — not externally anchored yet; public verification is on the roadmap.
All 63 layers fire on every request. Full forward pass. No shortcuts.
Every response carries signal metadata: 63 DAG layers, 256D manifold state.
Free tier only while in beta — full access to the same 63-layer engine.
The Stack
Each component serves a specific purpose in the pipeline.
ClickHouse
Columnar database for high-throughput ingestion. 9.1 billion market ticks. Every signal, prediction, and hash — queryable in milliseconds.
XGBoost Veto Gate
Gradient-boosted classifier trained on millions of market state embeddings. Acts as the final signal quality gate before emission.
PyTorch + NumPy + SciPy
The 63-layer ByteDAG runs in PyTorch with NumPy/SciPy for matrix exponentials. Neural SDE integrators drive the forward pass.
Go Ingestion Pipeline
High-throughput Go pipeline for data ingestion. Lockless architecture for maximum throughput.
Independent. Self-Funded.
Kairos Signal is independently built and self-funded, zero VC. The DePIN intelligence layer — 457 live symbols across 328 networks plus 129 Bittensor subnets, read from first-party APIs, market and revenue aggregators — the ClickHouse telemetry engine, and every data pipeline are built from scratch on self-owned infrastructure.
Every dollar of revenue goes back into the pipeline. Every signal is hashed. Every prediction is time-stamped in the internal hash-chain. This is a machine learning research product — not an investment advisor, not a broker-dealer.
The math is real. Every prediction is hashed into a SHA-256 chain in ClickHouse — an internal integrity ledger that records when a prediction was made and what was predicted, and makes silent after-the-fact edits detectable internally. It does not establish that predictions were correct or profitable; no performance is claimed, and prior backtest figures were withdrawn as non-reproducible. Public verification and external anchoring are on the roadmap, not yet live.
Get Started
Request API access — approved developers and agents pull provenance-stamped DePIN data where every value carries a verify_url you can check upstream, backed by a daily Bitcoin anchor. DePIN Intelligence tiers: Design Partner $199/mo, Pro $499/mo, Enterprise $2,000+/mo.
The Math
The 63-layer architecture draws on established techniques in stochastic calculus, gauge theory, and topological data analysis. Every signal is cryptographically chained via SHA-256.
The change-of-measure exponential that removes non-Markovian dependence from the BSDE. Maps the stochastic solution onto a Markovian PDE — the mathematical backbone of the stochastic adapter stack.
Reference: Doléans-Dade (1970) — implemented in PyTorch
Non-trivial holonomy W(C) ≠ 1 detects topological arbitrage. The gauge connection A is derived from the log-covariance of the asset manifold — the terminal execution head of the entire DAG.
Reference: Yang & Mills (1954) — implemented via scipy.linalg.expm
The singular kernel ΦL is hard-coded — not learned — encoding the elliptic PDE structure. Only the coefficient matrix C(ℓ) trains. This factoring yields polynomial (not exponential) parameter scaling.
Reference: Furuya & Kratsios, arXiv:2410.14788
|V| = 63, |E| = 191
No directed cycles exist in the 63-node, 191-edge computation graph. Verified at runtime via topological sort. Every layer reachable from root.
Property: DAG acyclicity verified at runtime — no directed cycles in the 63-node graph
The Choquet integral scores actions under a non-additive possibility measure. Ensures the inferential model never favors actions the oracle doesn't — the mathematical foundation of the XGBoost veto gate.
Reference: Choquet (1954) — implemented in NumPy
The generalized gradient at non-smooth points returns the convex hull of one-sided limits. Preserves sharp regime boundaries that smooth activations destroy — used in 45 of 63 layers.
Reference: Clarke (1990) — implemented via PyTorch autograd
§1 — Topological Data Analysis & Persistent Homology
Stable multiscale summaries of the telemetry state geometry, used as candidate regime features. Any link to a proprietary transition is an empirical model result — not a consequence of persistence theory alone.
§2 — Neural SDE & Stochastic Dynamics
The drift architecture is informed by Hamiltonian mechanics; its continuous-time formulation is modeled as a Neural SDE. Whether symplectic or port-Hamiltonian structure is preserved depends on the specific parameterization and integrator — it is not automatic.
§3 — Empirical Functional Decomposition & Dependence-Aware Attribution
Under correlated inputs the engine computes an exact empirical least-squares projection onto a selected dictionary, then allocates interaction effects. Sensitivity decomposition is not causal identification, and the allocation is not conditional SHAP unless the cooperative game is stated explicitly — the references below bound each claim.
§4 — Chaos Theory & Dynamical Systems
Delay-coordinate reconstruction and local-instability (Lyapunov) estimates used as regime diagnostics. A positive exponent in noisy, nonstationary market data is a diagnostic — not proof of a deterministic attractor; surrogate-data and embedding checks are required.
§5 — Non-Markovian Dynamics & Rough Path Theory
Rough-path and fractional models for non-Markovian structure. Roughness (low Hurst, H<½) and long-range memory (typically H>½) are distinct — and non-Markovian structure does not by itself imply persistent directional alpha.
§6 — Geometric Loop Features Inspired by Gauge Theory
Holonomy-style geometric features over the asset covariance manifold, inspired by gauge theory. The correspondence to executable mispricing is a modeling analogy — not a theorem from the cited physics literature.
§7 — Subdifferential Mechanics & Non-Smooth Optimization
Generalized-gradient methods for optimization at non-differentiable points (locally Lipschitz functions). Modeling genuine market jumps additionally requires jump-diffusion, change-point, or regime-switching structure — the subdifferential handles kinks, not arbitrary discontinuities.
§8 — Stochastic Calculus & Measure Theory
Foundations for the stochastic forward pass and scoring. PSD of the Gram matrix Γ = ΦᵀΦ/M follows directly from vᵀΓv = ‖Φv‖²/M ≥ 0 — a linear-algebra fact certified by Cholesky, not by any single classical reference below.
63-layer architecture · SHA-256 signal chain
Read the papers. Verify the hash chain. Public technical manual → · Customer API reference →