Omniscio

Performance Monitor (how the machine and the app are really doing)

One answer to "how is this performing right now?", read three ways from the same measurement — a panel, a local route, and a command — so a panel reading and a scripted reading can never disagree. Every block says how much of the window it saw and which of four states it is in, so a missing number can never look like a healthy zero.

On this page

What it is

One answer, three ways

Available three ways from the same measurement:

  • a panel — Performance Monitor, open to everyone since 2026-09-11,
  • an HTTP route — GET /perf/status on the local control server,
  • a command — the scorecard printed in a terminal.

All three read the same snapshot from the same place, so any number they both show agrees.

Every one of them answers within a budget — including the first call after a restart. A full reading takes seconds to assemble on a busy box, so a request that arrives before any reading has completed in this app run is answered at once with a COLLECTING answer: the monitor's own state plus how long the collect has been running, and no figures at all. It is never a guess and never a fabricated zero — every surface that would show numbers treats it exactly as "no reading yet" — and the collect it named carries on in the background, so the next call reads its finished report.

They do NOT all show the same numbers — but the whole-box gap is CLOSED. The 2026-09-07/08 false green (a spot Kernel share 41% with no duty beside it, reading busy-but-fine on a hanging box) was fixed: the panel now renders Kernel-bound share (kernelBoundPct, alarm at ≥50%), Storm verdict on (stormOnPct) and Sensor stood down (standDownPct) — see PerfStatusPanel.tsx.

One duty is still CLI-only: kernel-share SHADOW would-pace % (kernelShareShadowPct), which reads how much the kernel-share lever would have paced while switched off. So the panel can answer "is the whole box hung?"; for "what would the switched-off lever have done?", open the scorecard.

The box card now LEADS WITH A VERDICT — added 2026-10-06 (T-27). box.load answers "is this machine being harmed right now" in one word: ok, degraded, or unmeasured, with a reason naming the signal that tripped it. unmeasured is a real third answer: with the fault sampler silent, neither duty is measurable, and that is not the same as calm. Never on CPU percent alone — a box at 100% CPU with a clean kernel share is healthy, and a test pins that.

degraded NOW MEANS THE AGENTS ARE ACTUALLY SLOW — changed 2026-10-08 (T-211). It trips on the median agent tool call over 6 s (the tool-call tape's own 10-minute window, read through the existing recent-wait ring — no new sampler). The harm duties are still named, but as the MECHANISM: kernel-bound time over half the window, the fault-storm verdict over half the window, or a watched drive carrying the volume sampler's own sustained saturated verdict. signals lists what was in force, so it can be empty on a degraded verdict — the agents were slow with no duty crossed — and reason carries that sentence. Why: every one of those duties is pinned at its maximum as this box's steady state, so on its own the verdict read degraded around the clock and every gate keyed on it was permanently busy. A latency reading that is absent or under its sample floor is not a trip and not a clear: the verdict answers exactly as it did before, so a dead tape can never make a harmed box look calm.

The slow tail is shown and alarmed, never judged into the verdict — added 2026-10-15 (T-202). The agent wait row prints this computer's tool-call median AND p90 over the same calls, then the tail p90 (local p50 3.8s · p90 30s over 412 calls / 95 sessions in 10 min · tail p90 25s over 380 calls (32 long calls left out) — tail SLOW (goal 20s)), leaving out calls meant to take long: sub-agents, web fetches, archil tools, and shell waits, tests, builds and package installs. box.load.tail carries ok, slow-tail (tail p90 over 20 s) or inconclusive (under 10 calls or no reading). A tail p90 over 20 s for three watch ticks in a row (10+ minutes) raises one operator-only inbox card, "Agent tool calls are slower than the 20-second goal" — which on this box is the usual state (measured 2026-10-15), so it reads as a status against the owner's 3 s / 20 s goal, not a new fault. When the "Who is using this computer" setting is on and a recorded line under two minutes old exists, the card's body also ends with one sentence naming the dominant kind of owner and up to three biggest users ("Right now most of this computer is going to … (N%); the biggest users are …"); with no recent line the card reads exactly as before. The verdict itself still reads only the median, so a box can read ok while the tail is slow — that is the case the card exists for. Every watch tick also records the verdict and its inputs; boxLoadHistory on /perf/status and the load history row show the last 24 hours.

Why it was needed, and why it is not box.state. state is the block's READ provenance — it says the tape was readable — and on 2026-10-06 it read ok on a box that was 100% CPU, 59% kernel and kernel-bound 98.3% of the window, because every saturation duty reached only the checks and nothing fed them back into a verdict. state is unchanged on purpose: every check gates on it, and overloading it would make the app withdraw a hang card it had raised. The verdict rides its own field and shows up on the terminal row, the Box card in the Performance Monitor and the fleet feed; the evidence pack a mission reviewer receives gets an honest machine-load line from a separate change that reads the same duties rather than this field.

Alongside the readout, the app watches these numbers and raises an inbox card when one crosses its bound — on every computer for the nine a person can act on, and on the computer your team has set to watch the cloud fleet for the rest (see Who receives which card), so a machine in trouble reaches its owner without anybody looking.

One more card belongs to this family and is raised independently of this readout: when THIS computer's own agents get slow, the watching computer gets a plain-language card naming how many seconds a typical tool call is taking and the 4.5 s line this machine treats as harmed. It watches the LOCAL tool-call median — the same reading the box-load verdict and the dependency-install refusal already gate on — and counts only sessions on this computer, never rented cloud boxes (those return in about a tenth of a second and would make a slow machine read healthy). Like every card above it is sustain-gated, withdraws itself when the waits come down, is inbox-only, and carries its own off switch. It exists because that line had four consumers and every one ACTED on it while none TOLD you.

Where to find it

The Performance Monitor row in the sidebar, standalone and open to everyone (how long your agents' actions take is its Where agents spend their time section); the same numbers over the local control server's performance route; and the same scorecard from a terminal.

Two tabs when the early-access "Who is using this computer" setting is on (Settings, then Lab; off by default; desktop app only). The panel then opens on a Who is using it tab, which ranks what is using the computer in plain words, and the blocks described on this page sit unchanged on a second tab, Computer health. With the setting off, or outside the desktop app, the panel is the Computer health panel alone, as it was. The new tab is described on Who is using this computer.

The route is read-only and takes the same bearer token as the rest of the control server. A windowMin that is not a usable number of minutes is refused with a 400 instead of being replaced by the default window, because a caller who asked for one window and was handed another would read the answer as if it were the one they asked for.

How it behaves

Why it exists

Performance rules were already centralized: every throttle, gate and pacer in the app is a row in one registry with one off-switch accessor. The watching was not. It lived inside a single long-running AI session with a 30-minute alarm, a script under one person's home directory, and a notes file that was that session's memory. Findings were passed to other sessions by message — and when those sessions were archived, the findings went with them.

Worse, part of that instrument went blind exactly when it was needed: three of its measurements started a small external program, and when the machine ran short of capacity to start programs — the precise condition they existed to detect — they timed out and returned nothing. A measurement that dies of the thing it measures reports that thing as silence.

The rest of it kept working through those episodes because it read files instead. That contrast is the rule this is built on: reading a log cannot be starved by a program-starting pile-up; starting a program can. Everything here reads logs and values the app already holds.

What it reports

The panel answers one question per block, in words anyone can read: Box (CPU, kernel share, RAM free and available, event-loop lag) · Programs starting · App main thread (stalls, memory, blocking holds, GC pauses, and both the worst hold and the typical bad one — a run of short holds that repeats shows up in the second and never in the first) · Memory pool · Fleet, with live sessions now and the session limit · Disks and Drive activity (free space, runway hours, how busy each drive is and how long it takes to answer) · Other programs on this computer · Screen smoothness (freezes the app blocked versus late frames that blocked nothing, and the session count where it starts getting worse) · What caused the freezes, naming the program behind them · Room for more work, and what holds it back · Targets (the response limits the app holds itself to) · Background helper · Checks that timed out · Auto-lander · Load gates · Governor · Agent action time · Work rate. Every block says how much of the window it saw and which of four states it is in, so a missing number can never look like a healthy zero.

Three blocks are not on the customer panel because they are developer measurements with nothing a customer can act on: the Cloud verdicts share, the per-command call span breakdown and the phone timings. All three are still in the terminal scorecard and in GET /perf/status; the phone's own speeds are described on Performance Monitor — every block, in detail.

Every block in detail — one row per block: the question it answers, what its unreadable states mean, and what it is blind to.

Reading the plain blocks

Nine of those blocks exist to answer the question people actually arrive with — why does this feel slow? — so they are written as sentences rather than counters.

  • What caused the freezes names the program that moved most during each freeze, and what it was using (the processor, the disk, or Windows itself). It also says how many freezes it could not place, and why, so a partial answer never reads as a complete one.
  • Other programs on this computer asks the windows that are not Omniscio how long they take to answer. A high number here means the whole computer is struggling, not that Omniscio is slow.
  • Drive activity shows, per drive letter, how busy it was for the worst tenth of the window, what it was usually at, and how long an operation took.
  • Screen smoothness separates the freezes the app blocked from the late frames that blocked nothing, and names the session count where it starts getting worse.
  • Programs starting reports how fast this computer is creating programs, against the limit the app judges it by.
  • Room for more work answers whether this computer is at its limit right now, how many sessions it handles well, and what is holding it back.
  • Targets lists the response limits the app holds itself to, each with its reading and whether it is over.
  • Background helper reports the small helper program that carries Omniscio's own checks around every agent action: whether it is running, how long it takes to answer, and how often it restarted.
  • Checks that timed out counts Omniscio's own internal checks that gave up waiting, and how many of those happened while the app itself was frozen.

Each one shows a dash and a reason when it could not measure — a probe that is switched off must never look like a quiet machine.

Where the agents' own time went

Agent action time is the one block about your agents rather than your computer, and the one that answers "why do they feel slow".

It takes every tool call the agents made in the window and groups them by what the agent was doing — Bash:git, Bash:test, Read, sub-agents — then ranks those groups by the total time they consumed. Each row carries its call count, its typical wait, its slow-tail wait, its worst single call, its share of all agent waiting, and its error share.

Every row also carries its typical wait on a quiet box beside its typical wait on a busy one, and that pair is the point rather than a detail. The number here is what the agent waited — the hook time and the queue hold included — not what the command cost. Measured on this machine: an echo, which does nothing, has a typical wait of 883 ms with 0–25 sessions running and 10.6 seconds with 100–125. Every class behaves the same way. So a ranking on its own would tell you shell commands are your bottleneck, which is the opposite of the truth: the box was holding everything.

Read it as you read the rest of the panel — a row that grows between its two columns is the box queueing work; one whose columns stay close together while its total climbs is genuinely expensive.

The block also reports the model half: the vendor's own per-turn thinking time, recorded beside the tool waits, so you can tell "the model is slow" apart from "the tools are slow". Until the app is restarted onto a build that records it, that half reads as not measured rather than as zero. A turn whose thinking time cannot be told apart from time carried over from earlier work, such as the first turn after a resumed agent relaunches, also reads as not measured, and it is left out of the model-versus-tools comparison instead of counting as one very long think.

It states on its own face what it cannot see: that this is agent wait and not command runtime, that it covers app-spawned sessions only, and that a sub-agent's calls count against the session carrying them.

What the fleet finishes, by session count

Work rate is the second block about your agents, and the one that answers "at what load does the fleet stop getting more done". Where agent action time says how long each step waited, this block says how much work was actually finished while a given number of sessions was live.

It takes three records the app already keeps — completed agent turns and tool calls from the timing tape, branches the auto-lander recorded as landed, and the governor tape's once-a-second count of live sessions — and folds them into the same six live-session buckets the load curve uses. For each bucket it shows the minutes of tape covered, the session-hours accrued (live sessions × covered time) and the work finished per session-hour, beside branches landed per wall-clock hour. Both rates are shown on purpose: per session-hour says whether each session gets less done as load rises; per hour says whether the fleet as a whole finishes more or less.

A bucket with under ten covered minutes shows its counts and thin, never a rate, and a rate the fold withheld shows as a dash — never the word null and never a zero. An event whose session count could not be read is counted on its own unknown row rather than dropped into the quietest bucket. The land record states its own coverage — complete, partial with how far back it reaches, or not measured with the reason — so a window older than the record can never read as a slow lander.

The two peaks — the bucket with the most turns per session-hour and the bucket with the most branches landed per hour — are readings of the data. The block never recommends a session count; a falling rate at a higher bucket names where the app's own per-session cost has to shrink. It also says on its face that every bucket is time-correlated: the minutes the box spent at one load may be one incident, so compare a heavy bucket across days before reading it as a load effect. The same fold renders the WORK FINISHED section of the work-output readout, so the two can never disagree.

Two instruments name a freeze, and they answer different questions

When the app freezes, the tape records it twice, and the readout prints both without folding one into the other.

  • stall by is the operation tracker: a JS-level operation the app had started and can prove it was inside — a database write, a sweep. When it says (off-cpu-no-blocker) it is not failing; it is correctly refusing, because the thread was not running any app operation at all.
  • stack top is the CPU profiler: the actual frames sampled during the freeze, including native ones the operation tracker structurally cannot see — run (native) is the database driver's synchronous write, spawn (native) is the operating system starting a child process on the main thread.
  • stack site names the app function that CALLED that native frame. It is the only row that points at somewhere you can go and edit.
  • stack conf says what the two rows above are worth.

The two routinely disagree and both are right. A 27-second freeze on 2026-09-17 reported (off-cpu-no-blocker) from the first instrument and spawn (native) 45% from the second.

Read stack conf before you trust a percentage

The percentages are a share of the profiling window, not of the freeze. The profiler stays armed across a whole load window, which is typically far longer than the gap it is describing — a measured median of 28.6x, and at worst 569x. So 45% means 45% of everything the profiler watched, and on a badly over-long window the top frame is often (idle), meaning the profiler saw nothing in particular at all. stack conf states that ratio, how many freezes had no capture, and how many were led by an idle frame, so a number is never read as more than it is.

One number there moves the opposite way to the rest: when freezes the operation tracker declined to name start getting named by the profiler, the unexplained pile shrinks. That is coverage arriving, not freezes disappearing — the row says so in those words.

Runway is a trend, not a stopwatch

A worktree volume is a sawtooth: agents create checkouts and the reclaim drain removes them, so free space can swing by gigabytes every few minutes while its real trend is a few GB an hour. So runway hours is fitted across hours of recorded samples, never measured between two of them.

The line prints the span it actually fitted — 9.4 GB/h over 6.0 h — because that span is not the window in the header and nothing else on the page says so. Read over 6.0 h as the rate's own basis, not the event window above it. The rate once printed with no span at all, under a header reading (window 30 min); a reader took the two together and carried a reversed conclusion to the owner. The instrument was computing correctly the whole time — it was describing itself wrongly.

The disk card quotes that same fitted rate, so it states the same span — one formatter renders both, so the readout and the card cannot drift on how a span is written.

That matters when you read a scary number:

  • A short, sharp dip is not a deadline. Before 2026-09-12 the rate was the gap between the first and last sample in a thirty-minute window; on 2026-09-12 those landed on a local peak and a local trough, the readout printed 466.9 GB (26.4 h left, 17.26 GB/h), and an emergency was opened against a clock that did not exist — across those same six hours the volume gained 30 GB.
  • runway n/a is an answer, not a gap, and the line now says which one. It prints runway n/a (not filling) when the volume is draining, and runway n/a (too little history) when there is not yet enough recorded history to see past the swing (under thirty minutes of samples, which is normal for the first half hour after a restart). It never means the disk is fine, and it never means the readout broke — but those two readings are opposite (one is nothing to do, the other is nothing measured), so the line states which one rather than leaving you to guess between them. A rate that was never fitted prints a bare n/a GB/h with no span: a span beside an n/a rate would name the basis of a number that does not exist.
  • What a real alarm looks like: a sustained drop over hours. The one this deliberately keeps is a genuine 2026-09-08 event — 312 GB down to 200 GB, monotone, over six hours.

If you need the raw series rather than the verdict, it is on disk at <log dir>/perf-status-samples.jsonl, one row per volume per tick.

Four states, never two

Every block reports one of:

  • ok — it has an answer, and it saw a real stretch of time. If it saw less than the window you asked for, it says how much it saw.
  • point reading — it answered, but it saw no stretch of time at all: what it holds is an instant, not a measurement over a period. A live snapshot belongs here. So does any number that would otherwise be presented as a rate with nothing behind it — the readout refuses to call those ok, because an instant and a 30-minute window look identical to a reader scanning for good news.
  • unavailable — it could not read its source right now, and says why.
  • not on this build — the detector that produces it is not present in this build.

A point reading is not a fault: the numbers on it are real, and they are labelled with what they are. Ask "did this answer?" rather than "is this ok?" when you are driving a decision off a block.

This is the design's core rule: a missing number must never look like a healthy zero. "No refills were detected" and "nothing in this build can detect a refill" are different facts, and collapsing them is how a broken measurement reads as good news for hours. The same rule is why a per-session figure now prints the session count it was divided by — an average over 34 sessions and the same average over 75 are different claims, and a row that names neither cannot be argued with.

The same rule shapes the per-session cost row of the response targets (the fleet's cost to the machine, per session). When no session's cost can be read, the row carries no figure and says why. Where the reason is that no session accounting handle answered, it still says so and how many were refused. Where the reason is that the fleet safety governor is switched off on this computer, the row now says that instead of "N refused": "not sampling — the fleet safety governor is switched off on this computer (the owner's choice), so per-session cost is not being read". That is a choice, not a fault, and either way the row is unmeasured rather than a healthy zero.

The readout also states what it cannot see — most importantly, a window in which the app was not running at all. The tapes simply stop, so a dead app and a quiet app look the same here; a separate watchdog owns that.

Why the Box card is unreadable, in its own words

The Box card's CPU, kernel and storm numbers come off one family of log lines, and it once published a single fixed sentence — "no sampler or stall lines in the window" — for every window in which none of those lines carried a number. Five different things produce that state, and the sentence named none of them, so a reader could not tell a dead sensor from a failed Windows counter from a log that had rotated out from under the window, and there was nothing to act on but a restart.

It now names the cause its own evidence establishes, and hands the same sentence to the load verdict, whose unmeasured reason used to repeat the same unproven claim on every path that reaches it — including the two where the card itself reads ok (a caught stall line, or a tape that reached back under the five minutes a share needs) while both harm duties are null:

  • The counters are unreadable. The sampler writes its own statement that they are dark, and the card quotes it — with which of the sampler's paths failed, because that is what tells a reader whether a restart is the road. This is the only arm that is evidence about the sensor, so it is the only one a failed tape read may never overwrite.
  • The main log held no line at all inside the window. That is a fact about the log — a clock or offset mismatch, a gap left by a rotation, a logger that stopped — and not evidence about the sampler.
  • The tape reached back less than ten minutes, the interval the sampler restates a reading on. Silence over a stretch shorter than that is not yet evidence. The reason also says how much of the window you asked for it did see — "reached back only 6 of the 30 minutes asked for" — because a window the tape only partly covered and a window it covered in full are different readings.
  • No sampler line fell inside a window longer than that interval — an observation about the tape, which is as far as the evidence goes.
  • This platform has no fault sampler at all (the counters are a Windows facility), so the duties are unmeasurable here by design and the agents' own tool-call speed is the harm evidence.

None of this changes the verdict: a blind fault sampler still never reads as a calm box, the two harm duties still publish null rather than a fabricated zero, and the doctrine still says start nothing on unmeasured. What changes is that the reason a lead reads now says which of the five it is. The investigation and the residual risk are in the perf history.

The cards it raises

Each is sustain-gated (it must hold across consecutive checks before a card appears), withdrawn automatically when the condition clears, and carries a one-click action. None of them page a phone — they are inbox-only, by an explicit decision.

Each card raises at most once per 24 hours, and an empty inbox is therefore not a verdict. The cap is deliberate: a condition that stays true must not re-nag, and a card you dismissed stays dismissed for the day. One case is exempt — a card the app itself withdrew when the box recovered does not spend the day's budget, so a genuine second episode raises its own card. When the cap does hold a raise back, the scorecard's checks row says so next to the tripped check ([raise suppressed — the day's card for this check was raised at …]) rather than leaving a sustained check with no card and no explanation.

The same goes for a card type you have muted yourself in Settings → Alerts: the scorecard's checks row reads [no card — you muted this alert type in Settings → Alerts] next to the tripped check, and the panel's tripped list says no card — this alert type is muted in Settings → Alerts on that row, so a check that is over its limit and silent in the inbox is never unexplained. Both only report the mute; neither changes it.

The readout also carries the checks themselves, so you can see every bound and how close each one is without waiting for a card. That list follows the same three-state rule as everything else: until the first check has run it says "not evaluated yet" rather than showing an empty list, because "nothing is over its limit" and "nothing has been looked at" are different facts.

One check watches whether the fleet's git host is keeping up with your master, and the program that keeps it current has an owner switch. While that switch is off, the check does not read as "inside its bounds": the checks row lists it under could not be measured, with the reason fleet switched-off, and the panel says "nothing is over its limit, but one check could not be measured — so this is not a clean bill of health." That is deliberate — a switched-off producer means nobody is pushing your master to the fleet at all, which is the opposite of a quiet box, and it is exactly the condition that check exists to catch. It raises no card, because no bound has been breached; the honest answer is that the number is unknown.

The same check is also "could not be measured" on a computer that does not publish your master to the fleet at all — only one machine does that job, and a number computed on any other machine would be a zero that means nothing.

  • The app's main thread stalled 20% or more of the last 30 minutes.
  • A caught freeze held the harm verdict on for 50% or more of the last 30 minutes. That bound is the trigger, not a share of your time: one freeze keeps the verdict on for a full minute after it ends, so the figure tracks how often freezes arrive. The time you actually lost is the main-thread stalled share beside it on the same block.
  • A worktree volume has under 2 hours of disk runway left.
  • 40% or more of cloud runs in the last hour produced no verdict.
  • No branches landed for an hour while 5 or more were waiting — the dark lander case, distinct from the auto-lander's own backlog card, which needs the lander to have tried and given up.
  • A confirmed external-memory refill: the pool kept climbing for 90 seconds of the app's running time without a release (time the app spent frozen does not count). The card shows each counted source's share of the climb and an unattributed remainder — a large remainder means the producer is on a path nothing counts yet, not that a listed source is to blame.
  • Child processes are being started faster than 8 per second (every image combined — there is no per-program bound, so this is the whole box's spawn rate, not any one tool's).
  • The BOX was kernel-bound 50% or more of the last 30 minutes — the whole-computer hang that the app-side cards structurally cannot see. Every other card above reads Omniscio's own main thread, which is priority-boosted and reads fine while the rest of the machine crawls through the memory manager; this one reads the sampler's box-wide kernel-share verdict instead.
  • The desktop window was frozen by long frames for 30 seconds or more in the last hour — the DURATION twin of the stuttering card. That one counts long frames; this one adds up how long they blocked the window you work in, so an hour with a few very long freezes shows up here even when the frame count looks ordinary. It reads only the main desktop window, not a detached or web window, and it stays "unmeasured" until the tracing has covered most of an hour.

Four more watch the governors themselves rather than the machine. They are the odd ones out on this list, and deliberately so: each says that the thing built to PREVENT a slow box has stopped working, or has stopped being able to tell. None of them is claiming the app is slow right now.

  • The governor stopped recording what it decided. Every pacing threshold in the app is set by replaying that recording, so a gap in it cannot be filled in later.
  • The kernel disagrees with the CPU limits the app thinks it set — seen twice in a row, so it is a real disagreement rather than a check that arrived mid-write. Exactly one part of the app is supposed to set those limits, so a disagreement means something else did.
  • The governors were deciding without being able to see you. They all key on one signal: whether you are actually being slowed. While that signal is blind they are not cautious, they are uninformed — a window nobody could measure reads exactly like a calm one.
  • A governor asked for something that never took effect. "Asked for a limit" and "a limit is in force" are different facts; this is the card for the gap between them. It reads only policies in full enforce — which fleet pacing is by default since 2026-09-15, and which cooperative drain also is. A gap is a present-tense claim, so the card clears itself once the event behind it is old enough to be history — the drain expiry that once held it open for the whole life of the broker now stops counting as a gap an hour after it happened (2026-09-29). A job that was killed is not a gap either (2026-10-07): when a test job is force-stopped — replaced by a newer run, or cut off at a time limit — it cannot hand its slot back, so the slot returns two minutes later on its own. If the job's process is gone by then, the Performance readout lists it as a note ("N because the holder process had already exited") and this card stays quiet; if the process is still running, or the app cannot tell, the card still raises. The job types the card names are only the ones with a real gap (2026-10-08) — a type whose every timeout was a killed job is left out, so one real build-test timeout no longer reads as "build-test, git-rebase, ready-mint". A frozen referee is not a gap either (2026-10-10): the part of the app that hands out these slots used to take a slot back from a job that was still checking in, whenever the referee itself froze for a while on a busy computer — it woke up and judged before reading the check-ins that had queued up. It now gives its own frozen time back to every job first, and the Performance readout's cooperative-drain line says how often it froze ("the broker itself froze N time(s)"). If the card still fires, the job really did go quiet.

The single-freeze card reports the class the tape measured, not a generic load story. The [STALL-CAUGHT] line of the worst freeze has long carried what held the thread — blockedIn=syscall, syncFsInGapMs/topSyncFsOp for a blocking file operation, faultDelta/rssDeltaMb for a memory fault storm — and until 2026-11-11 no reader turned that into a class, so the card wrote the same body (and the same memory remedy) for every freeze. It now carries worstStallClass (sync-filesystem | memory-faults | null) and worstStallSyncFsOp for the same freeze worstStallOp names. On Help Desk ddd34b4a's tape the two worst freezes of the day were one blocking file open on C: with the processor idle (99% of a 19.7 s gap, 636 page faults) while the card offered Lite mode and closing memory-heavy apps; that class now names the disk block in plain English and offers a disk-shaped next step instead. memory-faults keeps the memory framing because there it is the measured cause, and null keeps the old copy byte for byte — the class is only ever printed when the tape actually measured it.

Who receives which card

A performance card reaches the computer where someone can act on it. Nine cards are delivered on every computer: the harm verdict, the three main-thread freeze cards, the three renderer cards, the whole-computer card and the background-launch card. Each is written in plain words for an installed copy, names what happened with its number, and offers one thing to try with a button that opens Settings → Performance on the Lite mode switch.

  • On any computer, a card a person can act on says what happened with its number and offers the one thing to try — Lite mode, or, when Lite mode is already on, something else — because the card is written for the copy that is running: a from-source build appends the engineering detail under "Technical details", and an installed build never sees it.
  • The first day is quiet. Eight of the nine are held for a brand-new user's first day, and the background-launch card joined them, so a first run does not open with a wall of warnings. The hold delays a card rather than losing one — the watch retries and raises once the window opens.

Using it

In a terminal the scorecard prints the plain 30-minute reading; --json gives the full report and --window-min <minutes> widens it. On the route a bad windowMin is a 400, never a silent default.

The command is a thin client over the route — no parser, no thresholds of its own — so it cannot drift from what the app believes. If the app is not running it says so, rather than reporting a stale file as current.

The panel shipped on 2026-09-11 and is no longer hidden behind Settings → Lab. It graduated from a gated grid of raw counters — faults per second, kernel-bound percentage, event-loop lag — once it could open with a one-line plain-language verdict and say what the app is doing about the numbers.

The watching, the alerts and the route were never gated on it and still are not — they are the product's performance ownership and run regardless. Gating them would mean the machine is only watched while somebody has a toggle switched on, which is the session-shaped ownership this replaced.

Ask it why it is slow — the one button

The panel opens with Why is it slow? and a Check now button. Press it and the panel answers in its own space: one short sentence about what this computer is actually doing, then at most one thing you can do about it.

The answer is always one of a small set of plain sentences, never a diagnosis it did not measure:

  • Nothing is slowing your computer right now. Nothing to change.
  • This app is working hard right now, and that is what you are feeling.
  • Your computer is spending most of its time answering file lookups rather than doing work.
  • Your computer is spending most of its time moving data to and from the disk.
  • Something is loading this computer heavily, and I could not narrow down what.
  • The window is doing too much work to keep up with you.
  • A drive is close to full, so work on it is slowing down.
  • Something in the background is stuck and is holding up the rest.
  • One of the checks on this panel is over its limit, but I could not narrow it further.
  • I could not check everything this needs, so this is not a clean bill of health. The line underneath names, in plain words, what it could not check.

Beside the answer sits one button — never a list. It opens the Lite mode switch, the Performance settings page, or the worktrees view, and it highlights the control it names. It never changes a setting for you.

Two sentences you will not see, on purpose. It never blames the number of sessions you have open: idle sessions cost very little, and the app answers about the machine it measured rather than about how you use it. And it never names a program it did not identify — "something is loading this computer" is the honest answer when the app can see the load but not the source.

The verdict is the same decision the app's own triage tooling makes, from the same reading the panel is already showing. Nothing is measured for it, nothing is sent anywhere, and the phrase "checked 4 minutes ago" tells you how fresh the reading is.

What the app is doing about it — the governance section

Below the readout, the panel answers the other half of the question: not "how is the machine doing?" but "what is being done about it?" Every agent-load governor is grouped under the plain-English mechanism titles the registry itself defines, each group showing how many are on, how many cannot be observed, and how many you can change. The mechanisms are named in exactly one place — the registry — and the panel reads those titles rather than restating them, which is why this page does not list them either. (Restating them is how the taxonomy previously drifted into four disagreeing copies, one of which said "priority" where the registry says demotion, so an agent grepping the prose found nothing.)

Where there is a switch and where there deliberately is not. Admission, pacing, priority, reclaim and machine strength get a toggle, because turning one off is a sane operator choice. Correctness fences, starvation floors, off-thread moves and sensors do not, and the panel says "always on" instead: a fence has to hold with every governor off — that is its definition — and a floor is the bound on how long background work may be deferred, so removing it is how a background pass waits forever.

Three answers it must always be able to give, for the same reason every block above states its own state:

  • unknown, never off — 53 of the 150 governors run in another process or bundle, so this process genuinely cannot read their live state;
  • not counted, never zero — 96 keep no act counter, and "nothing counts this" is a different fact from "it has never acted";
  • your settings could not be read — rather than resolving every setting-backed governor as off and printing a confident tally.

Why it exists: of 150 governors a human could reach 24 before this gap was closed.

  • Performance Monitor — every block, in detail — the reference behind the block table above.
  • Model throughput — how fast each model and vendor actually generates, measured from the same per-turn timing this panel's agent-action readout uses.
  • Felt-lag scorecard — the same machine seen build over build: typing, switching, freezes and blocked rendering, one row per build.
  • Perf control — the controls that decide what the app will slow down.
  • Who is using this computer — the early-access "Who is using it" tab that sits beside this panel's blocks: a ranked, plain-words list of what is using the computer, now or at a past time.
  • Resources diagnostic panel — the panel that reads this alongside everything else.
  • Local session limit — the cap behind the session limit row.

Last verified 2026-11-17