Open source · MIT Open weights · Hugging Face .NET · SQL Server · on-prem GPU Integrated, not a sidecar Built on FUSOR-1 REV 0 · reference build — coming

AORTA · The stat board seam

ROUNDS

The resident on perpetual rounds. A mind that lives inside your stat board — connected to a read-only replica of your own case database, holding every live case in one continuous attention state, rounding on all of them at once, around the clock. It catches the stalled case, the coverage gap, and the cross-case contradiction that no dashboard alert can even express — and surfaces them as one more lane on the board your team already watches.

GitHub · clone the example ↗ Weights · Hugging Face ↗ ← AORTA

FREE FOREVER. NO ACCOUNT, NO CLOUD, NO TELEMETRY. A COMPLETE, WORKING, DONE-FOR-YOU EXAMPLE — MODULE, EXAMPLE BOARD, ADAPTERS, WEIGHTS, AND THE TRAINING RECIPE — MEANT TO BE TAKEN, EXTENDED, AND MADE YOURS. NOTHING IT SEES EVER LEAVES YOUR BUILDING.

§ 01

Your stat board is a UI for human consumption.

Every OPO runs one. The live board: active donors, potential referrals, statuses, who's working what, which hospital, which OR, which clock is running. It is the operational nervous center of the organization — and it has one structural property nobody questions because it has always been true: the board exists to render database state pretty enough for a human to glance at. The intelligence consuming it has always been a person, walking past a monitor, holding maybe four cases in their head.

Which means the board's real limits are the reader's limits. A human reads one case at a time. A human is sometimes asleep. A human sees the case that's changing — never the case that has been suspiciously still for three hours, and never the collision between a note on case four and a timestamp on case nine.

Overnight · 02:40 · synthetic board

Three active referrals. Two coordinators on. Case 7's status reads "pending authorization" — unchanged since 23:52. Every individual alert on the board is green: no rule was ever written for "a case is quietly aging while everyone is busy," because that condition can't be written as a rule. It's a conjunction — case load × staffing × time-of-night × silence — and no one holds the conjunction.

ROUNDS, holding all of it in one attention state: wait — case 7 has had no activity for 2h 48m while both coordinators are attached to cases 3 and 5. Its clinical window is not paused just because its row is.

For the first time, the thing reading the board all night doesn't have to be a person. And it shouldn't read the board at all — it should read the database underneath it.

§ 02

Inside the board, on the database, on your silicon.

ROUNDS is not a chatbot bolted beside your application, and it is not a scraper reading your UI. It is a module you compile into your own stack — built for the .NET applications this industry actually runs, speaking to the database your organization already controls:

Reads the truth, not the render

A direct connection to a read-only replica of your case database. Every insert and update arrives as a live delta — no polling, no scraping, no five-minute scan. The change feed is the world arriving.

One attention state, all cases

Every live case, every status, every timestamp, held simultaneously in one resident context — which is precisely what no human reader and no per-case alert rule can do. The conjunctions become visible because someone finally holds them.

Surfaces into your board

Its output is one more lane on the board you already have — a component your developers own, rendered by your app, with one-key dismiss. Not a second dashboard. Not another tab nobody opens. The board, with a mind behind it.

The replica is the leash — the safety guarantee is infrastructure, not policy ROUNDS connects to a read-only replica. It cannot write to your database — not because a policy forbids it, but because the connection physically cannot. Its only outputs are entries in its own ledger and lines on its own lane. In a domain this serious, "the AI can't touch the record" should not be a promise in a manual. It should be a property of the wiring — and here, it is.

And the same logic that puts it on the replica puts it on your silicon: the case stream is PHI, it cannot leave the building, and therefore the mind that watches it must live where the data lives. No cloud API can be this product — not at any price, for the same reason your replica doesn't accept connections from the internet.

§ 03

What a mind catches that a dashboard cannot.

Dashboard alerts are rules — written in advance, per-field, per-case. Everything below lives outside that expressive range: conditions that are conjunctions across cases, absences rather than events, or facts that didn't exist when any rule was written.

The stalled case — silence as evidence

Nothing happened, so no alert fired — but nothing happening was the emergency. ROUNDS ingests the passage of time as world-state ("case 7: no activity, 2h 48m"), so it can act because nothing happened. Turn-based systems structurally cannot: no event, no trigger, no look.

The coverage gap — the conjunction nobody holds

Three referrals, two coordinators, and the arithmetic quietly stops closing. Every per-case rule is green; the emergency exists only in the cross-case view. This is the flagship catch, and it is case-centric by design: ROUNDS says "case 7 is uncovered" — it never grades a person.

The cross-case contradiction

Case 4's note says the OR is at 05:00. The logistics table says the team's aircraft lands at 05:20. Two tables, two screens, one impossibility — visible only to something reading both at once.

The timeline that doesn't close

Cold-ischemia clocks, OR windows, transport ETAs — arithmetic across three tables that no single view computes. ROUNDS reads the shape of the whole story and flags the sequence that cannot happen in the order the record claims.

The load curve forming tonight's crisis

Referral velocity climbing, on-call roster thin, two cases converging on the OR in the same hour. Each fact is fine. The sum is tomorrow's 06:00 emergency, visible at 23:00 — the cumulative condition no threshold expresses.

The render drift — the board lying about its own database

The tables say five active cases; the board renders four. A filter, a cache, a join gone quiet — and a case is invisible on the instrument everyone trusts. Because ROUNDS reads the replica, not the render, it is the one observer that can catch the board itself being wrong.

§ 04

The lanes — a recommended starting set.

ROUNDS watches your database as parallel lanes — typed streams of deltas, each a facet of the same living state. The reference build ships five; the module takes up to ten. Which tables feed which lanes is your institution's call — that's the part each organization fits.

CASE-STATUS

Every status transition on every live case — referral, evaluation, authorization, recovery, allocation — as it commits.

CLINICAL FEED

Vitals, labs, med changes as they post: the ground truth every note and every plan gets checked against.

ASSIGNMENT

Who is attached to what, on-call state, shift boundaries — the staffing half of every coverage conjunction.

CLOCKS & LOGISTICS

OR windows, transport, ischemia timers — the lane where timeline arithmetic lives.

TIME ITSELF

Sparse ticks: elapsed silence entering the stream as world-state. The lane that makes the stalled-case catch possible at all.

+ YOURS

Notes, referrals-intake, external interfaces — any table with a change feed can be a lane. Adapters are small and yours.

Why not a script every five minutes? — the honest answer A cron-scan is presence sampled at five-minute resolution, and it re-reads the whole board every time, blind between samples. ROUNDS is caught up at every moment — each delta lands in an attention state that already holds everything prior, judgment fires the instant a condition completes (measured tens-of-milliseconds boundary-to-judgment on the reference bench, not minutes), silence itself is perceived rather than skipped, and the module's forming attention can be aborted mid-thought when the world contradicts it. And because it holds state, it composes with what came before: "this same pattern, third time this week" is not a query anyone wrote — it's memory.

§ 05

The Human Line.

Same doctrine as every AORTA tool, enforced by construction — these are not features deferred; there are no code paths to these places:

ROUNDS will never

Write to your database. The read-only replica makes this physical, not procedural. It cannot alter one byte of a case.
Touch allocation or viability. Which organs, which candidates, go/no-go — clinical judgment stays human, entirely, forever.
Grade a person. Every catch is case-centric: "case 7 is uncovered," never "coordinator X dropped it." It is not a productivity monitor, and its ledger is about cases, not staff.
Page anyone on its own. It surfaces to its lane on the board. Whether a flag escalates to a phone is your workflow's decision, under your rules, wired by your team.
Send PHI anywhere. On-prem or your own cloud tenancy; air-gapped is a supported configuration. Nothing to breach, because nothing leaves.

And the boundary running the other way, same as always: one keystroke dismisses any flag — and every dismissal becomes a labeled example in your ledger, teaching the disposition your organization's sense of what deserves attention. That record accrues on your infrastructure, and it is yours.

§ 06

The plate, and what runs it.

ROUNDS rides the FUSOR-1 resident substrate — bench ratings measured, dated, receipted in the reference build's public runs ledger:

Quantity	Rating	Receipt
Thought-boundary detection (judge exactly where a condition completes)	0.97 vs 0.02	ingest logits, free
Lag — completed condition → judgment rendered	~327 ms	workday replay, 1×
Honest recall across a working context	≥ 98,304 tok	planted multi-hop spans
Abort a forming conclusion when evidence lands	13 µs	branch kill
Multiple seats, one attention state	1.208×	worst-case co-decode
Memory fold, self-authored (a day held resident)	14.8×	all planted facts survive

SUBSTRATE RATINGS, REFERENCE BENCH: ONE CONSUMER RTX CARD, 9B-CLASS OPEN WEIGHTS. ROUNDS HAS NO CLINICAL OR OPERATIONAL PERFORMANCE NUMBERS YET, AND THIS PAGE WILL NOT PRETEND IT DOES. EVERY DEMO IS PROOF-OF-MECHANISM ON SYNTHETIC DATA — THERE IS NO LIVE INSTALLATION TODAY, AND THIS PAGE WILL SAY SO UNTIL THERE IS. THE SHADOW-MODE LEDGER AT YOUR OWN ORGANIZATION IS DESIGNED TO PRODUCE THE REAL NUMBERS, ON YOUR DATA, UNDER YOUR REVIEW.

Runs today

9B · one RTX card

The reference fit: 9B-class open weights, quantized, 16 GB VRAM. The full mechanism, modest judgment — the proof-of-loop tier.

Recommended

27B · RTX PRO 6000

27B-class open weights (Qwen3.8-27B, Apache 2.0, shipped Aug 2026) resident on one 48 GB workstation card — deeper judgment, ~10 lanes, still one box under your desk. For a healthcare org, this is modest hardware.

Headroom

H100 / H200

Room for a bigger tuned model, longer resident context, and the second-opinion tier behind the seam — still on-prem, still yours.

On the FUSOR-1 substrate

FUSOR-1 is the open, MIT-licensed resident-kernel substrate — the loop, the bus, and the laws for minds that don't take turns. ROUNDS is a fit: the substrate pointed at a living database. VIGIL — the handoff watchman — is its sibling at the document seam; the two are designed to peer: committed, signed records cross between modules on one internal bus (never forming thoughts, never PHI beyond your walls), so the mind on the board and the mind on the sign-out can each know what the other has established. Peering ships as a seam in the reference build; ROUNDS runs whole without it.

§ 07

A done-for-you example. Take it and make it yours.

ROUNDS ships as a complete working reference, open end to end — because every OPO's board is a little different, and the point is not to sell you a black box. The point is to prove the mechanism is real and hand you everything needed to make it your own: the module, an example stat board, the adapters, the weights, and the entire training recipe. Improve it, re-tune it, gut it for parts. It's yours.

# the repo (GitHub · MIT) /module the FUSOR resident core + the .NET host (service or container) /example a complete synthetic stat board (.NET 8 · SQL Server · realistic fabricated cases) /adapters the change-feed lane adapters (SQL CDC / Change Tracking → typed deltas) /surface the board-lane UI component (rendered by YOUR app; one-key dismiss) /training the full recipe: data generation, tuning scripts, eval battery (reproducible) /ledger schema for the append-only judgment log (lands in YOUR database) # the weights (Hugging Face · open) 9B-class disposition-tuned GGUF available with the reference build 27B-class disposition-tuned planned; the Apache-2.0 base shipped Aug 2026 — the recipe ships either way, so tune your own # run the example, end to end, on synthetic cases git clone https://github.com/bochen2029-pixel/aorta-rounds dotnet run --project example # the board, with fabricated live cases rounds.exe --replica <connstr> --shadow # watch-only: writes the ledger, flags nothing

Shadow mode first, here too: ROUNDS installs watch-only. For its first weeks it surfaces nothing and simply writes its ledger; your team reviews what it would have flagged — the morning brief — and turns the lane on when the record has earned it. Trust is a receipt, not a promise.

GitHub ↗ Hugging Face ↗ Meet VIGIL, its sibling →

STATUS: REV 0. THE SUBSTRATE IS PUBLIC AND MEASURED; THE ROUNDS REFERENCE BUILD IS BEING ASSEMBLED FROM IT. EVERY CLAIM ON THIS PAGE STAYS PINNED TO WHAT THE TAPE CAN BACK.

The board always showed everything. Now something sees everything.

Every case, every clock, every quiet gap between updates — held at once, around the clock, by a mind on your own hardware whose only powers are to read a replica and to say wait. The stat board was built so humans could glance at the database. ROUNDS is what happens when the database finally gets a reader that never looks away.

Built by OPO people. Free because the mission is the point. Honest because the ledger is the product.