$ATLAS

What holding it does

One row moved out of the paid column on 2 Sep 2026. /api/v1/feeds was listed as something holding unlocks; it returns the same bytes as the public data.json, so it unlocked nothing. Selling it would have been a claim anyone could disprove with one curl, on a page whose whole argument is that it does not overstate. What holding actually moves is time, memory and notice — the three rows above it.

250,000 of a fixed supply of 1,000,000,000 — 0.025%. The supply is fixed at launch. The launch itself runs on a Pons V2 bonding curve: buys and sells go through the curve until it reaches a graduation threshold of 4.2 ETH. That figure is read from the curve contract, not from documentation — the interface is undocumented, and the docs describe a different factory. Measured 3 Sep 2026.

This is the shape of the thing you are buying, not a description of it — one ticker from one weekend in /api/v1/archive, exactly as it comes out:

{
  "startedAt": 1787968800, "endedAt": 1788134400, "runs": 157,
  "liveFeeds": 35, "maxFrozen": 33, "peakFrozenVolume": 2256968.73,
  "tickers": {
    "MSTR": {
      "maxAbsBasis": 0.8751039901715326,
      "signedBasisAtPeak": 0.8751039901715326,
      "maxCycles": 378.4,
      "volume24h": 555771.83,
      "everDivergent": true
    }
  }
}

7 weekends of that, one file each, plus the precomputed replays. It is the only thing here a competitor does not get by shipping the same tool tomorrow.

Deep-pool tickers only, and deliberately: pools under $50k are already excluded from the composite signal, so a fresher number on them would be a faster way to learn nothing. The fast lane covers every ticker where the signal can actually fire.

Precisely what it is, because the difference matters: the fast lane re-reads the Chainlink side only — the oracle price and when it last printed. It does not re-quote the DEX, and it never overwrites the full read. Basis, cadence, flags and the public page still come from the 20-minute sweep, which stays the complete picture. Two reads, kept separate on purpose: a partial read stitched into a complete one and served as current is the exact mistake this project was built to catch.

Who this is for

The page is for reading. The dataset is for working, and those are two different acts — which is why the reading stays free and needs no wallet. Someone who reads the page is not a customer who slipped away; they are how anyone finds out this problem exists.

Three situations, stated as what the page cannot do rather than as what the token unlocks:

• You lend against these tokens, or price them as collateral. The page tells you which of the 170 have no oracle publishing right now, and the weekend pages are free to read. What it does not give you is those weekends as data — one file each, plus the precomputed replays — which is what you need to ask what your own threshold would have done, instead of taking mine.
• You build something that reads one of the 35 live feeds. The 20-minute read is the complete picture and stays public, in data.json. What it cannot do is tell you sooner. /api/v1/fast re-reads the Chainlink side every 60 seconds on the deep-pool tickers.
• You need to know when something changes, not what it is now. Reading a page on a schedule is polling, and polling a 20-minute file every minute finds nothing nineteen times. The Telegram alerts fire on transitions.

None of that is a claim about how much any of it is worth today. The lending exposure this site measures is on the front page with the amounts attached, including the part where nobody is being liquidated over it today. What is being sold is earlier notice and a record you can compute against — not a prediction that either will pay.

What is being built

No dates. Dates are the one part of a roadmap nobody can verify in advance, and the first thing thrown back at you when they slip. Every line below carries its own check instead — when it ships, you will not have to take my word for it.

1. Run our own node. This chain produces about 153 million blocks a year and the public RPC refuses long log queries — the full-history scan behind the "never published" claim took eight passes to finish. Trading fees pay for it. You will know because RH_RPC_URL changes in the public Verify repo, in a commit anyone can read.
2. On-chain evidence inside every register entry. Today an entry says a condition opened on a ticker at a time. It should carry the feed address, the round, and the price that was being served. You will know because one getRoundData call reproduces any entry you pick.
3. The register as raw data, not only as a page. The log is thousands of rows of HTML. The underlying append-only files should be downloadable, so the counts published here can be recounted by someone else. You will know because events/2026-09.jsonl answers 200 and re-counting it gives the numbers on the log page.
4. Turn the exposure figure from a declared upper bound into a measurement. It currently assumes lending markets price collateral with the feed measured here — that assumption is stated on the front page and has not been verified. You will know because each position carries oracleVerified: true | false | unknown — three states, because "I could not check" is not "it is fine".
5. A real incident, replayed with this method. Nobody has lost money to a frozen feed on this chain yet, and saying otherwise would be a lie. Elsewhere they have. The question worth answering is whether this signal would have caught it, and how early. You will know because the replay script runs from your machine, not mine, and produces the same dates.
6. A page for when this is wrong. Openings that cleared within one cycle, flags that never confirmed. A declared false positive is worth more than ten quiet catches. You will know because every acknowledged error gets a dated line there, and none of them ever gets deleted.
7. Stop asking a block explorer anything. coverage.mjs is broken right now because an explorer put its API behind a challenge, and the token census depends on the same service. Names should not be how this project finds things — that is the argument it makes about everything else. You will know because node coverage.mjs exits clean with the explorer unreachable.

What I build, and what I commit to

I write and run every part of this: the watcher, the archive, the API, this page. These four commitments are mine alone to keep, and all four are checkable from outside today.

1. The free tier stays free, without a wallet, permanently. Every number on the public page — 205 tokens, 35 live feeds, the 170 with no oracle, staleness, basis — stays open to everyone, and so does every weekend page and the record index. The measurement is the public good, and so is the ability to check it. What holding pays for is the dataset.
2. The access threshold can only go down, never up. I cannot price anyone out of something they already bought into.
3. The measurement never changes because of the token. No ticker gets flattered, no flag gets softened, nothing gets hidden because it is inconvenient. Every number comes from public RPC calls against chain 4663 and a public DEX quote — you can reproduce all of it without me.
4. What is unproven stays labelled unproven. That is the whole reason to trust anything else on this site, and a token does not change it.

Three things worth stating plainly

• The measurement does not depend on the token. It was here before $ATLAS existed and stays the same whatever the token does — the commitment above says how, and you can check it without me.
• I build and run Oracle Atlas, and the paid tier is gated on this token. That gives me a reason to want this chain to look good, and the job here is to say when it does not.
  $ATLAS is not a claim on anything — not equity, not revenue share, not a promise of future work.
• $ATLAS trades on the chain this site grades. Pons launches on Robinhood Chain, so the token lives on 4663 — the same chain whose oracles I measure and publish findings about. That gives me a reason to want this chain to look good, and the job here is to say when it does not. I would rather name that myself than have it named for me.
  What answers it is not a promise to be impartial, because you have no way to check a promise. It is that no number here needs my impartiality: every oracle reading is a public RPC call — the two that are not, lending collateral from blue-api.morpho.org and the token census from an explorer, are named where they appear — the scripts under Verify make those calls for you, the transition log is append-only and never rewritten, and the record page counts the weekends it missed. If I ever softened a finding, the chain would still say otherwise and you would need thirty seconds to see it.