ACU (Acurast) — the network, measured

Generated 2026-10-12T04:30:01Z from live ClickHouse queries against this estate's ledger. Held inventory: 29,567 observations · 36 distinct series · 3 upstream sources · first row 2026-08-09 17:15:20 · newest row 2026-10-12 03:50:46 · 29,567/29,567 rows carry a verify_url. 34 series refreshed in the last 24h (609 fresh rows). Nothing on this page is cached, estimated, or remembered.

Provenance — where every number comes from

3 source families feed this network's ledger. Every row they wrote carries its own source, as_of and verify_url; this table is the live rollup of that.

30-day history — headline series (daily last-value, live)

One row per series: latest value, a 30-day sparkline of daily last-known values (scaled to the series' own min→max), day count, and window change. Series absent from the 30-day window are omitted from this table, not zero-filled.

Market reference — CoinGecko coin page, as held

Market-data reference rows: price, supply, capitalisation, diluted valuation, and the published change columns including ATH/ATL. These are the coin-page reference's own numbers — the estate does not model, smooth, or forward-fill them. The change columns / rank / ATH-ATL / high-low series start later in the archive than the price rows (each metric's caveat in the full inventory states its own first-held row) and are shown from their first held row. The circulating and total supply rows are different quantities (circulating vs total) and are never netted against each other or against the diluted valuation — different quantities from the same endpoint, shown side by side.

Fleet telemetry — Acurast's own processor-management service, read directly (first-party class)

Direct reads of Acurast's own infrastructure (processor-management.acurast.com/processor/debug/cache/status) by this estate's collector: the service's processor-cache size (processorCache.size → cached_processors) and device-status cache size (deviceStatusCache.size → cached_devices). This is the strongest provenance class in the ledger: the upstream is the network's own infrastructure, and the verify command re-runs the exact call the collector ran against the same URL. The counters are published exactly as the service reports them — cache-status counters as Acurast measures its own fleet visibility; no interpretation beyond the field names is added. Two further cache fields (battery_health_cache_size, network_type_cache_size) exist as archived single rows from the Go collector era (2026-08-09), published under their own held rows, never merged into the current family's rows or back-filled.

Developer velocity — GitHub API, as held

Developer-activity rows read from GitHub's public API for Acurast/acurast-substrate (stars, forks, open issues, watchers, days since last push) and the Acurast organisation (public repos). Published exactly as GitHub reports them, each with the api.github.com endpoint it came from as its verify_url.

Token & chains — the catalog row, as held

The catalog's reference fields for ACU, queried live from default.depin_catalog at generation. The estate holds NO per-chain on-chain token rows (no RPC reads of balances or supply against these contract addresses), so no on-chain token section is published — absence, not zero. Live cross-check at generation: catalog contract address matches the platform map returned by the CoinGecko coin-detail endpoint on: ethereum.

Full metric inventory — 34 measured series, each with provenance

Every series held for ACU with rows in the last 30 days: latest value, when it was observed, which source observed it, how many rows we hold, how many of the last 30 days it reported, its comparability grade, and the origin link. "days/30" counts distinct dates with at least one row in the window.

Revision ledger — 0 backward revision(s) recorded for ACU

Backward revisions are values upstream later replaced for a date we had already archived. The before-value is retained — that retention is the only reason a rewrite is detectable, and it is the part every overwriting vendor discards.

The ledger query ran during generation and returned 0 rows for ACU. Zero here is the live query result, not a gap — the ledger itself is at /v1/revisions.

Verify any cell yourself — the exact commands

No account, no key, no trust required. Commands 1–3 hit the same upstream endpoints our collectors do — Acurast's own processor-management service (the collector's exact URL, with the field extraction inline), the CoinGecko programmatic endpoints (the coingecko.com browser coin page 403s plain curl, so the programmatic endpoints are given, id acurast — markets for the price/supply rows, coin detail for the contract platform map), and GitHub's public repo/org endpoints; command 4 hits this estate's public API, where every row carries the same source / as_of / verify_url fields. One polite call per endpoint, no hammering.

# 1) Acurast's OWN processor-management service — the collector's exact call
#    (keyless, as of 2026-10-12T04:30:01Z):
# 1) Acurast's OWN processor-management service — the collector's exact
#    call (keyless, as of 2026-10-12T04:30:01Z). Fields read by the estate:
#    processorCache.size -> cached_processors, deviceStatusCache.size -> cached_devices.
curl -s "https://processor-management.acurast.com/processor/debug/cache/status" | python3 -m json.tool
# field extraction, the two quantities the estate publishes:
curl -s "https://processor-management.acurast.com/processor/debug/cache/status" | python3 -c "import sys,json; d=json.load(sys.stdin); print('cached_processors:', d['processorCache']['size'], 'cached_devices:', d['deviceStatusCache']['size'])"
# 2) CoinGecko public markets API (the endpoint family our collector
#    reads for the price/supply/cap rows) — the coingecko.com browser
#    coin page 403s plain curl, so the programmatic endpoint is given
#    (id: acurast):
curl -s "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=acurast" | python3 -m json.tool
# 2b) The catalog token contract, cross-checked against CoinGecko's
#      platform map for acurast (prints chain -> contract per platform):
curl -s "https://api.coingecko.com/api/v3/coins/acurast?localization=false&tickers=false&market_data=false&community_data=false&developer_data=false" | python3 -c "import sys,json; d=json.load(sys.stdin); [print(k, '=', v) for k, v in (d.get('platforms') or {{}}).items() if v]"
# 3) GitHub — the dev-velocity family reads the repo and org endpoints
#    directly (unauthenticated, rate-limited — one polite call):
curl -s "https://api.github.com/repos/Acurast/acurast-substrate" | python3 -c "import sys,json; d=json.load(sys.stdin); print('stars:', d['stargazers_count'], 'forks:', d['forks_count'], 'open_issues:', d['open_issues_count'])"
curl -s "https://api.github.com/orgs/Acurast" | python3 -c "import sys,json; d=json.load(sys.stdin); print('public_repos:', d['public_repos'])"
# 3b) Human-view check of the verify_url target (the browser coin page 403s plain curl — that is the documented 403, the programmatic commands above are the verification path):\ncurl -s -o /dev/null -w "%{http_code}\n" "https://www.coingecko.com/en/coins/acurast"
# 4) This estate's public API row for ACU:\ncurl -s "https://kairossignal.com/v1/network/ACU" | python3 -m json.tool | head -60

Method & honesty notes. All counts are queries against the live ledger at generation time, not restamped copy — this page is regenerated by gen_deep_dive_acu.py and the hourly claim_drift_check.py run grades its claims against the live API like every other published surface. Comparability grades come from the served canonical-metric system via its own resolver: total_supply maps to token_supply_total (question-verified). The remaining series are ACU-native fleet/market/dev metrics with no cross-network concept; grading them would be fabrication, so they are labelled "acu-native (unmapped)". The fleet telemetry family reads Acurast's own processor-management service with the collector's documented field paths (processorCache.size, deviceStatusCache.size), and at generation time the upstream probes ran as follows — probe decoded the endpoint live in this process: processorCache.size=11235, deviceStatusCache.size=12031. cached_processors: probe == latest held row (11,235) cached_devices: probe == latest held row (12,031)The catalog token contract is published as held and was live cross-checked against the CoinGecko platform map at generation (catalog contract address matches the platform map returned by the CoinGecko coin-detail endpoint on: ethereum); the estate holds no on-chain RPC rows for these contract addresses, so none are implied. The two archived Go-collector-era cache rows are published under their own held timestamps, never back-filled into the current first-party family. The CoinGecko circulating and total supply references are different quantities, never netted; the estate holds no chain-side issuance read for ACU. The estate grades are published exactly as the engines served them, unflattering parts included, and are not re-derived from any series on this page. Where a section has no data, it is absent — we do not publish zeros for gaps. Upstream probes ran serially by this generator immediately before rendering: Acurast processor-management cache/status (GET) HTTP 200; CoinGecko coin detail (platform map) HTTP 200; CoinGecko markets API (acurast) HTTP 200; GitHub repo Acurast/acurast-substrate HTTP 200; GitHub org Acurast HTTP 200; estate /v1/network/ACU HTTP 200.