Is Watch itself working?

A quiet phone means a quiet night or a Watch that could not reach you. A public page says which, and this is what it checks, what it cannot see, and what covers the rest.

On this page

When nothing has arrived #

You wake up and your phone has said nothing. Either every agent got on with its work, or Watch was not there to tell you otherwise. From the phone the two look the same.

One page tells them apart: status.nucarium.com.

It needs no sign-in and reads with JavaScript off. It is about Watch, not about you: it holds nothing from any account, so it cannot tell you how your boxes are. For that, open the inbox.

The console links to it as Watch status, in the sidebar and in Settings. When the console cannot reach Watch at all, its error page links there too.

What the page says #

The first line is one of five:

The page says It means
Watch is working. All three checks passed, the last time the page looked.
Watch is answering, but part of it is failing. The API answers, and something behind it does not. Reports from boxes may be refused, and alerts may be late or missing.
Watch is not answering. The API did not answer at its public address. No box can report, and nothing alerts.
This page has not checked Watch since 14:05 UTC. The page has not looked in the last fifteen minutes. It does not know, and it does not repeat its last answer as if it were still true.
This page has not checked Watch yet. The page has never looked.

Under it is when the page last looked. When Watch is not working, a second line says since when:

Under the first line
Checked every five minutes. Last checked 14:05 UTC, 20 Nov.
Since 13:40 UTC.

Then one line for each check, in these words:

Check Passing Failing
The API The API answers. The API is not answering.
The registry It can read its registry of accounts and machines. It cannot read its registry of accounts and machines.
Environment state It can reach the state it keeps for each environment. It cannot reach the state it keeps for each environment.

A check can also read "Not checked". For the last two that means the API gave no report, so the page knows neither way.

Every time on the page is in UTC. It is the same page for every reader, and it runs no script that could ask where you are.

The last 90 days #

Below the checks is one line for each of the last ninety days, newest first:

The last 90 days
20 Nov: problems for about 30 minutes.
19 Nov: no problems seen.
18 Nov: no record.
A day reads Because
No problems seen. Every look that day found Watch working.
Problems for about 30 minutes. Six looks that day found something else. Each stands for five minutes, so the figure is a count of looks, not a stopwatch.
No record. The page did not look that day. Days from before the page existed read this way.

A day runs from midnight to midnight UTC.

What it checks #

Every five minutes a small program asks the Watch API three questions. It is a separate program from the API, so an API that has stopped cannot report itself healthy.

  1. Does the API answer? It requests https://api.nucarium.com/healthz at the public address, the way a box reaches it.
  2. Can the API read its registry? That is the database of accounts, machines and environments. Without it Watch cannot tell whose box is speaking.
  3. Can the API reach the state it keeps for each environment? That is where sessions and their deadlines live. The API writes one row and reads it back, in a store that belongs to no environment.

The second and third come from one request to the API, described below. All three passing is "working". The first failing is "not answering". Anything else is "answering, but part of it is failing", which includes an API that answers and gives no report on the other two.

None of the three reads or writes anything of yours. The page does not check Watch because somebody opened it, so a crowd reading it during an outage adds no load to the thing that is failing.

What it cannot see #

The platform Watch runs on. The page and the check behind it run on Cloudflare, as Watch does. They catch Watch being broken. They do not catch Cloudflare itself being down: then the page may not load, or its "last checked" time stops moving. Read a page that will not load, or one that says it has not checked since some time ago, as "nobody knows", not as good news.

A short outage. The page looks every five minutes. Something that breaks and mends between two looks is never seen.

Your side of the line. The page asks from where Watch runs, not from where your box is. If your router, your DNS or your network provider is in the way, the page says "working" and your box still cannot report. nucleated check on the box answers that.

Your alert destinations. The page sends no alert. A destination that has stopped accepting them looks fine from here. The destination's test button answers that.

The console. The three checks are of the API, which is what boxes report to and what sends alerts. The page does not load app.nucarium.com.

What covers the rest #

A check that runs beside the thing it checks cannot be the only one. The other one is on your box.

Give nucleated an address of your own and the box tells you itself when it has not been able to reach Watch for ten minutes, and again for each session that starts waiting on you while that lasts. It needs nothing from Watch or from the status page, so it works when both are gone. The on-box notifier is a few lines of config.

Between them:

What has failed Who tells you
Your box, or its network Watch: the box goes dark and you get one alert.
Watch, with its platform still up The status page, when you look. The notifier, without your looking.
Watch and its platform together The notifier. The status page may not load.
Your box's network and Watch at once Nobody, until one of the two is back. A box that can reach nothing cannot reach your address either.

Set the notifier up before the night you need it.

While Watch is not working #

Your agents do not depend on Watch. It only looks, so nothing it does or fails to do stops a session. What you lose is the telling:

  • Sessions carry on, and one that stops to ask you something waits as it always does. Check your vendor's app for anything that is waiting.
  • The box keeps what it could not send. Every event waits in the spool and is delivered, in order, when Watch answers again.
  • Nothing needs fixing on the box. Do not sign it in again or restart the daemon. It retries by itself.

The same facts as JSON #

Everything on the page is also at one address, for a script or a status board of your own:

Workstation
curl -sS https://status.nucarium.com/status.json
Output, with most of the 90 days left out
{
  "status": "degraded",
  "since": "2026-11-20T13:40:00.000Z",
  "checked_at": "2026-11-20T14:05:00.000Z",
  "interval_s": 300,
  "components": [
    { "id": "api", "status": "ok", "since": "2026-11-02T09:15:00.000Z" },
    { "id": "registry", "status": "ok", "since": "2026-11-02T09:15:00.000Z" },
    { "id": "objects", "status": "failing", "since": "2026-11-20T13:40:00.000Z" }
  ],
  "days": [
    { "date": "2026-08-23", "status": "no_record", "checks": 0, "failed_checks": 0 },
    { "date": "2026-11-19", "status": "ok", "checks": 288, "failed_checks": 0 },
    { "date": "2026-11-20", "status": "problems", "checks": 170, "failed_checks": 6 }
  ]
}
Field What it is
status operational, degraded, down or unknown: the page's first line, in the order of the table above, with both "has not checked" lines as unknown.
since When that status began. For unknown it is the last time the page looked, or null if it never has.
checked_at The last time the page looked, or null.
interval_s Seconds between looks: 300.
components The three checks, always in this order: api, registry, objects. Each has a status of ok, failing or unknown, and its own since.
days Ninety days, oldest first, ending today. Each has a date, a status of ok, problems or no_record, the number of checks made that day, and how many were failed_checks.

Times are RFC 3339 in UTC. The answer is the same for up to thirty seconds, and any web page may read it. Its shape is fixed by a JSON Schema at https://status.nucarium.com/status.schema.json, which allows no field but these.

Treat unknown as its own answer. A script that reads anything but down as healthy tells you Watch is fine when nobody has looked.

This is not part of the Watch API. It has no account, takes no token and is not in the API's contract.

The readiness request #

The second and third checks are one request that the API answers about itself. It is public, and you can make it:

Workstation
curl -sS https://api.nucarium.com/readyz

GET /readyz

Whether the API can do its work: read its registry database, and make a round trip to a Durable Object, the storage that holds each environment's state. /healthz says the Worker is serving. This says what stands behind it answers too.

Nothing it reads or returns belongs to any account. The registry check reads no row. The object check writes one row and reads it back, in an object that is no environment's.

200 when both checks pass. 503 when either fails, with the same body: this is the one response outside 2xx in this API that is not a problem document. A failed check says that it failed and how long it took, never the error's text. A check that has not answered in five seconds has failed.

Limited to 12 requests a minute per client address.

Responses #

StatusMeaning
200Both checks pass.
429The caller is sending too fast (rate_limited). Wait Retry-After seconds.
503A check failed. The body is a Readiness with ok: false, not a problem document.
200 response
{
  "ok": true,
  "service": "nucarium-api",
  "version": "0.1.0",
  "checked_at": "2026-11-20T14:05:00.000Z",
  "checks": {
    "registry": {
      "ok": true,
      "duration_ms": 12
    },
    "objects": {
      "ok": true,
      "duration_ms": 31
    }
  }
}

Each entry under checks says whether that check passed and how long it took, in milliseconds. A 503 carries the same body with ok: false, so whoever asks always gets the report. Every other error from the API is a problem document.

The status page does not draw on the limit of twelve a minute. It asks over a private connection inside the platform Watch runs on, not over the internet.