Evidence row 297640

What was observed

{
  "count": 7,
  "tools": [
    {
      "description": "Every current per-region reading RealUptime holds for one catalog service, both endpoint roles, with per-region status, latency, measurement timestamp, and whether each reading is still fresh. This is the regional detail behind is_service_down: use it to answer \"is X down in Europe\" style questions, or to show that reports and our check readings disagree in a specific region. Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "service": {
            "maxLength": 64,
            "minLength": 1,
            "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
            "type": "string"
          }
        },
        "required": [
          "service"
        ],
        "type": "object"
      },
      "name": "get_regional_readings"
    },
    {
      "description": "How many people are reporting problems with one catalog service right now, by region, and whether that is unusual against its own trailing baseline. Returns a per-region count of reports and distinct reporters for the most recent five-minute window, a spike verdict of \"spike\", \"normal\" or \"insufficient_data\", and RealUptime's own check reading for the same regions so the two signals can be compared without being merged. These are UNVERIFIED user reports: no account, no verification, and the region on a report is chosen by the person filing it. Report volume never opens, extends or closes a probe event in RealUptime's event record; only our checks do. \"insufficient_data\" means there are not enough reports to say anything, which is NOT the same as reports being normal, and must never be quoted as \"no problems reported\". Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "service": {
            "maxLength": 64,
            "minLength": 1,
            "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
            "type": "string"
          }
        },
        "required": [
          "service"
        ],
        "type": "object"
      },
      "name": "get_report_volume"
    },
    {
      "description": "One \"my stack\" page: a named set of RealUptime-tracked services, each with the SAME plate level its own page shows (down / partially_down / degraded / partially_degraded / blocked / no_data / partially_unverified / up, with label and clause), plus the stack's roll-up: `summary.headline` (\"2 of 6 services with checks failing or degraded\"), the worst member level, and counts by state. Pass `stack`, the stack's slug (from its URL, https://realuptime.io/outages/stack/<slug>) or id. Stacks are built at https://realuptime.io/outages/stack or from a Monitor dashboard; there is no list endpoint, a caller must hold the key. User reports and public chatter are not read for a stack (those signals are published as null), so `reachable_reports_elevated` never appears here; a member's own page still shows it. A member whose own status feed RealUptime reads is levelled by the vendor's declared incident instead of our checks (`services[].vendor.feed_working` is true, its plate label says so, major or critical reads as down, minor as degraded, none as up, and no probe event is listed for it); `summary.counts.vendor_incident` and `vendor_quiet` count those members apart from the check counts. An unknown key answers `summary.level: \"not_found\"`, which says nothing about any service's health. Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "stack": {
            "maxLength": 96,
            "minLength": 1,
            "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
            "type": "string"
          }
        },
        "required": [
          "stack"
        ],
        "type": "object"
      },
      "name": "get_stack"
    },
    {
      "description": "How the internet looks from RealUptime's check regions right now (https://realuptime.io/outages/internet-weather): for each of the ten regions (iad = US-East, sjc = US-West, fra = Europe, nrt = Asia-Pacific, ord = US-Central, yyz = Canada, lhr = UK, sin = Southeast Asia, syd = Australia, gru = South America), the latest hour's p50/p95/p99 response time across the ~195 public services in RealUptime's outage catalog, the region's 7-day baseline, and a `state` of \"normal\" / \"slower\" (only after three consecutive hours over 1.5x the baseline, clearing at 1.25x) / \"no_baseline\" / \"no_data\", plus a 24-hour sparkline and the last 30 days per day. This is a picture of a REGION's vantage point over many services, NOT any one service's latency and NOT customer monitoring traffic (which never enters this aggregate). `coverage.typical_claim_allowed` says whether the record is old enough (30 days) to call a figure \"typical for the region\"; until it is, say \"compared with the last 7 days\" instead. Takes no arguments. Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "internet_weather"
    },
    {
      "description": "Do RealUptime's own checks of a third-party service currently fail, from named regions? A check is one unauthenticated request to the service's front door; it says whether that check passed or failed, not whether the service works for users. Returns a verdict of \"up\" (our checks pass), \"down\" (our checks fail), \"down_in_some_regions\" (our checks fail from some regions), \"blocked\", \"no_data\", or \"not_covered\" (the service is not in RealUptime's catalog). When the service's status feed works, `vendor` carries what the vendor itself declares on its status page, and the verdict, `verdict_source` and plate then come from that declaration alone (down while its live incident is rated major or critical, otherwise up); our own reading is `checks_reading`, shown beside it. Also returns `plate`, the public page's headline: one level from down / partially_down / degraded / partially_degraded / reachable_reports_elevated / blocked / no_data / partially_unverified / up, with its label and the sentence under it. \"reachable_reports_elevated\" means our checks pass but user reports or public chatter are above their spike threshold: NOT a failed check, and never to be quoted as one. Pass `region` (iad = US-East, sjc = US-West, fra = Europe, nrt = Asia-Pacific) to ask about one region only. Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "region": {
            "enum": [
              "iad",
              "sjc",
              "fra",
              "nrt",
              "ord",
              "yyz",
              "lhr",
              "sin",
              "syd",
              "gru"
            ],
            "type": "string"
          },
          "service": {
            "maxLength": 64,
            "minLength": 1,
            "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
            "type": "string"
          }
        },
        "required": [
          "service"
        ],
        "type": "object"
      },
      "name": "is_service_down"
    },
    {
      "description": "Is there a shared-infrastructure incident right now (Cloudflare, an AWS region, a CDN), as inferred from RealUptime's own checks across every service it tracks? Answers one of three levels: \"ok\" (no shared incident; a count of services whose checks fail travels with the catalog size), \"provider_incident\" (our checks fail for at least five services sharing one provider signal while our checks of services on other providers mostly pass; the provider is named with the services affected and a confidence sentence), or \"several_unrelated\" (our checks fail for several services with no shared provider signal). Also returns the dependency map from our checks: how many tracked services answer from behind each provider. A provider incident is a CORRELATION of our check readings, never a cause the provider stated, and it changes no service's own verdict; ask is_service_down for a specific service. Takes no arguments. Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "is_the_internet_down"
    },
    {
      "description": "Past probe events RealUptime recorded for one catalog service whose status feed we cannot read. For a service whose feed works, `recent_events`, `last_outage` and `reliability` are `available: false` with the reason (the vendor's declared incidents are what count, our probe events are not listed or counted), and `vendor` leads. A probe event opens only when our checks fail from two or more distant regions. Returns `last_outage` (the most recent CLOSED probe event, with its duration, regions and surfaces, or the plain statement that our checks did not fail from two or more distant regions in the N days we have checked the service) and `reliability` (per calendar month for the last 12: uptime by our checks, probe event count and minutes, from probe events only; a month before we watched the service is tracked: false with no percentage, never 100%) and `recent_events` (the probe events of the last 90 days, most recent first, at most 10, the open one included: for each, started_at, ended_at (null while open), duration, peak_level (down / partially_down), the regions and surfaces involved with their per-facet legs, and detected_by, which is always \"probe\"). An empty list travels with window_days and tracking_since and means our checks did not fail from two or more distant regions in that window since we started checking the service, never \"this service has had no outages\". Events that fail our rules are retracted and listed at https://realuptime.io/outages/corrections. The current reading travels alongside. Readings are RealUptime's own check readings, never user reports. For a service whose status feed we can read, `vendor.feed_working` is true and `vendor` holds the vendor's own declared incident from its status page: that statement leads and gives the verdict and plate, and `checks_reading` and `vendor.regional_reading` are our check reading beside it, never a second outage. Where we cannot read a feed (`vendor.feed_working` false), the answer is our checks alone. \"blocked\" means our check was refused, which is NOT a failed check of the service. A no-data answer is never a passing check. Our check readings are our own reading from outside, not the service's official status. `check_evidence`, when it is not null, says what a pass of this service's check shows and does not show: repeat it with any claim that the service works. Cite the returned source.url when repeating any of this.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "service": {
            "maxLength": 64,
            "minLength": 1,
            "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
            "type": "string"
          }
        },
        "required": [
          "service"
        ],
        "type": "object"
      },
      "name": "list_recent_incidents"
    }
  ]
}

What the leaf hashes

{"body":"f0d916b7dea6e26293ebb769b77647fe2317028bd97f35942b7f4bb911acf26c","id":297640,"kind":"mcp.tools","method":"probe.mcp/1","observed_us":1793052270595461,"prev":null,"subject":"627c944a-707b-468e-bb8b-a6d1fade7516","subject_kind":"endpoint"}

Proof

Fold these into the leaf in order, hashing each sorted pair with keccak256, to reach the root of 2026-10-26 (296695 rows).

1. 0xc518eaf0f368daab336f5f4d09880dce4950e97a4f9b46d6c108e4a0e5ccae53
2. 0x35852cf81bfa72c2e38c23fb85835da8a174d33e49a8b12f67f87e4ecdcd73c1
3. 0x07cecd367848716ee18b0e2ff51b8dbc6d6b676951592ecf85383bcbf5939b88
4. 0x686865b080a53c7520e8453d1a5a7da6b69b7d383cf13eca21111dcf2ad357de
5. 0xc7d72fc39faa9fb7d6dbe238b474c92084ff3b1064c4741824472bdbbc0a4fff
6. 0xfc87ef30151d732db99ec89d7d4424a85cd43d2a46fe9e669ee68107e325c72c
7. 0xb659fa6ae19ecd699520921235291f3b494e8133515259f13ab37fef6e381851
8. 0x088023faebdbeb63056fe67f3190f0a11193635689984fe6461d85b667ae0760
9. 0xefd18e61652a0f8f4eec75422a55aa67dab46013e02c2c584b5f7645b529a240
10. 0xae71c3940eac3236f4c68fb44d25cc1262b73d017fd7c18fbff1248c2e850602
11. 0x463fef738ef71a01d4aa9ac1c6836fcf6802cdaa7de01bbe42397d79d35d8671
12. 0x4d1a020de7fc0aa076daeb62ebb904d51ac6c607b605eb63a7855f34d7b69f1b
13. 0x641fba1f23ec69d96721e34ace1926954d835b9614cb5eae215a069c056399b8
14. 0xdbe2e8dd65ea1248b2936612538f18268abd5cf27ebdab3737694571ad496004
15. 0x9f68b5e15459cb62b8c0cd4c124fa61c74147b4a5755a200fbecd21a581635d1
16. 0x123ec8bee20ddc55223eeef5a4f4d6c4b6416515adbb911c56759f5cde56e452
17. 0xd0651cb9bc8155eb52b5247d506e74b8a935057dc190ba52091702ac25ed3a40
18. 0x9a9024edb5069d88a324facb310a5ce8e495214bbaa968f077bede437390194f
19. 0x9b9ce5b74b9bab5121612ef6b64920a8d453cbf311096a423eef9702747e868a

Day root

0xf43e8dcc3d451a4788b26be904c55e8c4c0fa75c9666796c51db38d37e2c0df8

Chained

0x702d5ac508f08b0d1accf36af25822d8e5660367494edd17a642fb61e158a57a

Published

On Arc Testnet, block 69251483: 0x495162f8936e19f0039918feebe6c307f327cd6bf8c37219620b1970041fa9ae