Cluster Architecture
Status: vision — grounded by measured prototype hardware results.
A production PRISM installation is a rack of consumer graphics cards, each serving exactly one ensemble model, coordinated by a single management server. The design needs no enterprise hardware — and the prototype has already proved the per-card sizing by measurement, not estimate.
One model, one card
The unit of the ensemble maps directly onto the unit of hardware. PRISM's method is an ensemble of independently trained models that vote — five in the prototype, on the order of a hundred at production scale — and each model occupies one consumer GPU. A card loads its model plus steering adapter and spends the day doing one thing: continuing patient tables from the screening queue. Inference nodes hold no state beyond the model in memory, coordinate with nothing but the management server, and never talk to each other.
Everything else lives on the management server, a single more capable machine per installation:
| responsibility | what it does |
|---|---|
| assignment | distributes patient batches across available cards; tracks which models have voted on which patients |
| aggregation | collects continuations, reads fires, tallies consensus per patient |
| retraining | runs the rolling one-model-per-day refresh cycle |
| explanations | hosts the separate explanation model that writes the physician-facing narrative |
The nodes recognize patterns; the management server does everything that makes the recognition operational.
Consumer cards on purpose
Consumer GPUs cost a fraction of their enterprise counterparts, and PRISM's workload — one 9B-class model per card, batch throughput, no concurrent-user serving — never needed more. Replaceability matters as much as price: a failed card is a commodity part from any supplier, swapped as routine maintenance rather than procured as a project. There is no vendor lock-in and no architectural tie to a hardware generation; the rack refreshes at the pace of the consumer market.
The sizing is not a projection: the prototype measured that a 16 GB consumer card serves the full context as a complete node, and that capacity grows by adding cards rather than buying bigger ones — the hardware notes carry the numbers.
Network isolation
Inference nodes connect to the management server and to nothing else — not the insurer's systems, not the internet. Each node receives a patient table, returns a continuation, and knows nothing beyond that exchange. This eliminates whole categories of security concern by construction: there is no path from a node to sensitive systems and no route out for data. The management server is the one controlled connection point — encrypted, authenticated, logged — which is also where a security audit can focus, instead of on a distributed system. The installation runs inside the insurer's own data center on PRISM-managed hardware; patient data never leaves the building.
Graceful degradation
Models are files. Every model lives on the management server, and any card can load any model — so when a card fails, its model is reassigned to surviving cards, which work through it after their own. A patient's evaluation is complete only when every ensemble model has voted, so hardware failure costs time, never votes. In the limit, the entire ensemble could run on a single card, loading each model in turn.
What the design deliberately omits is redundancy theater. Screening suggestions are not a critical-path system: no uninterruptible power, no failover clusters, no spare hardware standing idle. If the rack loses power, the only consequence is that suggestions arrive later — care proceeds exactly as it would have without PRISM, because silence is never a recommendation. When power returns, processing resumes where it stopped.
Linear scaling
Patient evaluation is embarrassingly parallel: each history is continued independently, with no coordination between evaluations. Doubling the cards doubles the daily throughput, from a pilot rack upward, with no redesign and no diminishing returns. Capacity planning reduces to arithmetic — population size times evaluation frequency, divided by per-card throughput. And early hardware is never throwaway: a pilot's cards remain exactly as useful beside later additions.
The honest boundary: this is a design, not a deployment. The piece that exists is the prototype's five-node fleet — the small-scale instance of this same pattern (one card, one model, one coordinator). Per-card sizing and throughput are measured; the orchestration layer — redistribution, the retraining scheduler, the explanation model — is not yet built.