How it works
Six columns in. More rows out.
Agreement counted.
There is no diagnosis engine anywhere in PRISM. A patient is a table of billing codes; a model's entire job is to continue that table; a suggestion exists only when several independently trained models continue it the same way. This page walks the mechanism end to end.
The route
From claims record to physician flag, in six moves.
A patient becomes a six-column table
Standardized billing codes, one row per medical event — the only thing any model ever sees.
A developing condition leaves a trail
Visits, refills, referrals, escalations — a pattern written into the record long before its explanation is.
A model does one thing: continue the table
No prompt, no chat, no reasoning. A suggestion "fires" when the continuation contains a specific diagnostic test.
Timelines cut themselves into training material
Three code sets define a condition; GOOD, BAD, NOPE, and FAKE examples extract themselves — no chart review.
Independent models vote
Disjoint pools, one model each, nothing shared. Because they share nothing, agreement is evidence.
Two training rounds build each specialist
A primary round makes a model that can only continue the table; a light secondary round teaches it when the test belongs in the continuation.
1 · The patient timeline format
A patient is a table.
Every patient PRISM considers is a single markdown table with six columns, and that table is the only thing any PRISM model ever sees — in training and at inference, with no exceptions. No metadata channel, no side input, no instruction describing the task. The table is the whole world, and continuing it is the whole job.
Every example — training sequence or live prompt — begins with the same fixed two-line header:
| PERSON | WHEN | WHERE | WHO | WHAT | WHY | | ------ | ---- | ----- | --- | ---- | --- |
That header is 28 tokens and never varies; in the running system it is served from a single database view rather than hard-coded anywhere, because supposedly-fixed values have changed before. Everything after it is one medical event per row, in date order, until the history runs out.
| column | contents | example |
|---|---|---|
| PERSON | age and sex, nothing else | 34 female |
| WHEN | date of the event, ISO format | 2023-04-17 |
| WHERE | place of service, a POS- code | POS-81: Independent Laboratory |
| WHO | provider taxonomy, a NUCC- code | NUCC-207Q00000X: Family Medicine |
| WHAT | the procedure, product, or medication | CPT-82197: Serum veladrin / regulatory-mineral ratio, quantitative |
| WHY | diagnosis code or codes, ;-joined | ICD-E27.A4: Suspected mineralocorticoid-axis dysregulation |
The WHAT and WHY examples are fabricated codes from Primary Veladrin Excess, the 2026 prototype's invented condition — they sit deliberately outside every real codeset but wear the exact format real codes do. POS-81 and NUCC-207Q00000X are real codes.
Those cells, assembled into a row
| PERSON | WHEN | WHERE | WHO | WHAT | WHY | |
|---|---|---|---|---|---|---|
| … | … | … | … | … | … | |
| TEST | 34 female | 2023-04-17 | POS-81: Independent Laboratory | NUCC-207Q00000X: Family Medicine | CPT-82197: Serum veladrin / regulatory-mineral ratio, quantitative | ICD-E27.A4: Suspected mineralocorticoid-axis dysregulation |
A row assembled from the per-column examples above — illustrative, and synthetic by design: the condition and its codes are fabricated. The TEST mark is an annotation for you, the reader; construction marks are bookkeeping that no model ever sees, in training or at inference.
Medications are the one place the format departs from the code on the raw claim. Pharmacy claims use NDC — an 11-digit code that is precise about the wrong things: no therapeutic hierarchy, and the same pill from two manufacturers gets two unrelated codes. So a medication renders as ATC-{atc}-{rxcui}: {name} [#units DS:days] — therapeutic class first, then the specific drug, name, quantity, and days of supply — as in the prototype's invented ATC-C03DZ01-211582: veladrostat 12.5 MG Oral Tablet [#90 DS:90].
No invented vocabulary
PRISM invents no medical vocabulary: every coded cell comes from a finite, documented billing standard the American healthcare system already speaks — the same codes every insurer processes and every provider bills with. Every code is paired with its short human-readable description, so a model reads CPT-93785: Ambulatory blood pressure monitoring rather than a bare number.
Hierarchy carries meaning
ICD-10-CM codes beginning with I are circulatory: I10 is essential hypertension, I11 hypertensive heart disease — the progression is legible in the codes themselves. Even place-of-service codes tell trajectory stories: office → emergency department → treatment facility is a severity arc written in WHERE alone.
Finite and auditable
Closed sets with published definitions — on the order of 70,000 ICD-10-CM codes, around 10,000 CPT codes. Vast by human standards, trivially small for a language model, and stable enough that a clinician can look up exactly what each code denotes. There are no mystery tokens.
Already familiar to models
Billing guides and clinical documentation saturate pre-training corpora, so a base model arrives pre-exposed to these codes. Pre-exposure is a head start, not a guarantee — the specialization itself is what the training rounds exist to build.
What models never see
| never model-visible | what it is |
|---|---|
| construction marks | SIGNAL / IMPACT / TEST / EARLY / LATE labels that slice timelines into training material |
| pool assignment | which of the disjoint training populations a patient belongs to |
| patient identifiers | any key linking rows to a person — names, member IDs, or internal record numbers |
A model that fires does so because it recognized a pattern in ordinary-looking rows, not because anything flagged them.
Honest limits
This is a claims history, not a chart: it records that a test was billed, never what the test found — no lab values, no vital signs, no clinical notes. PRISM's anonymity guarantees and its recall-not-prediction posture both depend on exactly that poverty of input: the format sees enough to notice a pattern worth checking, and structurally cannot see enough to pretend to a diagnosis. More on the posture →
One last property of the format is quietly load-bearing. JSON ends with a bracket; XML ends with a closing tag; both give a model a grammatically natural place to consider the sequence finished. A markdown table just stops — another row is always grammatical. That cooperates with a rule explained two sections down: PRISM's models are never allowed to stop.
2 · Utilization phenotypes
What a developing condition leaves behind.
A medication stops working and gets escalated. A vague symptom earns an office visit, then another. A specialist is consulted for one piece of the picture, a different specialist for another. An emergency room absorbs a crisis at 2 a.m. that no scheduled appointment caught. Each of those events produces a billing record, because everything that expects payment produces a billing record.
The sequence of those records — what was done, where, by what kind of provider, justified by what diagnosis, in what order and at what tempo — is the condition's utilization phenotype (glossary). It is the thing PRISM actually learns to recognize.
Objective
No interpretation, no documentation-quality variance, no missing notes — the record is what was billed.
Complete across providers
Each provider holds only a slice of the journey. The pattern no single office can see is intact in the one place the slices reunite: the claims record.
These phenotypes typically begin before anyone knows what they are looking at. The healthcare system responds to symptoms long before it names causes — treatments tried, tests ordered, referrals made, all of it billed — so by the time a diagnosis code finally appears in a record, the phenotype may have been legible for months or years. That precedence is the entire opportunity, and it is what "early" means throughout this site: not predicting the future, but recognizing a pattern already present in the record before its explanation is.
PRISM never defines a phenotype explicitly — no rules, no feature lists, no clinician-authored criteria. Training examples are selected by outcome anchors (a test, and what followed it), so nobody has to know what a condition's phenotype is for the models to absorb it.
Honest limits
The 2026 prototype built one phenotype by hand — for the fabricated condition Primary Veladrin Excess — under strict signal isolation, and showed the machinery recognizes exactly that pattern and nothing else: the ensemble fired when precursor rows were present, stayed silent when they were stripped, and needed as little as one recognizable event to fire. The honest converse: if a condition leaves no learnable precursor pattern in claims, this method has nothing to find. Whether real conditions leave such patterns — rich enough, consistent enough, present in claims at all — is the open question the real-data phase exists to test, condition by condition.
3 · Sequence completion
The only task: continue the table.
The model receives a billing history rendered as a table — the fixed two-line header, then one row per claim, oldest first. It produces more of the same table: the rows that would plausibly come next. No system prompt, no instruction, no question is appended. The input is data; the output is more data. PRISM's specialists are never asked anything: they are shown a table and they continue it, because continuing it is the only thing they can do. (The front page shows one continuation live.)
A screening suggestion fires when the continuation contains the diagnostic TEST code for the condition being screened. Checking is string matching, not interpretation — in the 2026 synthetic proof of concept, a search for one fabricated code, CPT-82197, anywhere in the generated rows. Asked what plausibly comes next for this patient, the model answers "this test."
"Should this patient be screened?"
A hard question to hand to a machine. Answering it directly makes the system a decision-maker: weighing risk factors, justifying a recommendation, defending a threshold, audited as though it were exercising clinical judgment.
"What usually comes next in a record like this?"
The question a language model is natively built to answer. If, across a model's training pool, histories like this one tended to arrive at a particular test, the plausible continuation contains that test. The screening decision is never made anywhere in the system — it falls out of sequence statistics.
Intentionally broken models
Catastrophic forgetting — a model losing its general abilities under narrow fine-tuning — is the textbook failure mode of specialization. PRISM makes it the training objective. By the end of primary training, a specialist cannot hold a conversation, answer a question, follow an instruction, or explain itself; show it anything other than a patient table and it produces table rows anyway. The narrowness pays twice: capacity (every parameter spent on the one distribution that matters) and surface area (a model that can only emit billing-table rows has no other behavior available to misfire with).
| common failure mode | why it has no purchase here |
|---|---|
| prompt injection | there is no prompt to inject into — the input is rows of standardized codes, and any text inside a row is just more sequence to continue |
| jailbreaking | there is no refusal boundary and nothing behind one; the model has no capability beyond emitting table rows |
| unfaithful reasoning | there is no reasoning chain — nothing is generated between the history and the continuation |
| hallucinated explanations | the model never explains anything; checking its output means checking whether a code appeared, not auditing an argument |
| prompt-engineering drift | there is nothing to engineer — the "prompt" is the patient's history, assembled the same way every time |
None of this claims the system is failure-free. Individual specialists are noisy by design; the claim is narrower — the failures that remain are simple and inspectable, and no single continuation is ever the verdict.
Forced continuation: a recall instrument, never a predictor
At inference, every model is denied its end-of-sequence token and forced to keep continuing the table for a fixed budget — this round, roughly 1,500 tokens, ten or more complete rows. A model allowed to stop would be making a statement: ending the table reads as "nothing more is coming," which is exactly the calibrated no-need prediction PRISM must not emit. Banning the token removes the option entirely — and the markdown format, with no terminator to reach for, cooperates instead of fighting.
| outcome | what it means | what happens to it |
|---|---|---|
| the TEST appears (a fire) | "consider this test" — a pattern worth a human look | counted toward consensus; may become a suggestion to a physician |
| the TEST does not appear (silence) | nothing | never stored, scored, or reported as any statement about the patient — not "low risk," not "cleared" |
Only one of these is an output at all. A fire is a flag; silence is the absence of a flag, and PRISM keeps no ledger of it — there is no "screened and negative" record anywhere in the system, because the system cannot produce that claim in the first place. The prototype could measure this principle, not just assert it: every miss on a signal-bearing patient traced to one mechanical cause — a model fires if and only if its prompt contains at least one precursor row — so silence reflected missing input, never a low-risk read of the patient.
Constructive-only architecture
The pipeline counts positive suggestions only; no component can emit "don't test." Denial is unrepresentable, not merely suppressed — impossible to build.
Results-based compensation
PRISM is paid only when a suggestion leads to a documented early detection. No revenue path runs through gatekeeping — denial is unprofitable to want.
4 · Three-pattern learning
Timelines cut themselves into training material.
Three sets of billing codes are all it takes to define a condition for PRISM — the diagnostic test, the early treatment, the late treatment. From those three sets, every training example the method needs extracts itself from the coded timelines, with no chart review anywhere in the loop.
| mark | what it names | in the prototype |
|---|---|---|
| TEST | the diagnostic test whose appearance in a continuation is the screening suggestion | CPT-82197, the quantitative serum veladrin ratio of the fabricated condition PVE |
| EARLY | treatment indicating the condition was caught in time | recurring refills of one simple maintenance tablet |
| LATE | treatment indicating it was missed until it caused lasting damage | recurring clearance sessions at a dialysis-style facility — an ongoing institutional burden |
The TEST is the pivot: every timeline that contains it is classified mechanically by what follows — early treatment, late treatment, or neither. That classification is the whole of "labeling" in PRISM. No diagnosis field, no outcome adjudication, no clinician judgment. (The prototype carries two further marks, SIGNAL for the injected lead-up and IMPACT for accrued damage, only because its condition was injected and every injected row had to be accounted for; real records need no such marks.)
Four kinds of example, four lessons
GOOD — the success story
Teaches the target behavior directly: given a history like this, the test comes next — and early treatment follows.
BAD — the tragedy
Replaying the tragedy would teach that late is normal, so the prompt is paired with a caught-in-time continuation instead. BAD carriers teach the correction, not the mistake.
NOPE — the ruled-out test
The specificity control. Without NOPE, a model could look good by suggesting the test for everyone; NOPE makes silence on unaffected patients a trained behavior rather than an accident.
FAKE — the earliness teacher
Not a kind of patient: a FAKE is manufactured from each BAD example by moving the prompt cut roughly twenty rows earlier. Same lesson as BAD, asked from less history.
The TEST sits in the preferred column for GOOD, BAD, and FAKE and in the dispreferred column for NOPE — that pairing is the entire design.
How "earlier" gets an operational meaning
Firing the test is only half the goal; PRISM has to surface it earlier than the historical record did. FAKE is how that is taught — and, at evaluation time, the only way it is ever measured.
Schematic, not to scale. In the prototype's build, BAD prompts end about 11 rows before the test row and FAKE prompts about 31 rows before it — this round's construction offsets, not constants. If a model fires on the FAKE prompt, it surfaced the test before the data did. The read stays binary — the TEST code appears in the continuation or it does not; there is deliberately no lead-time score. The marks shown are bookkeeping for you, the reader: no model ever sees them, and the underlying timelines are synthetic by design.
The extraction is deterministic queries over coded timelines: find the test code, look at what follows, cut, graft, done. Every qualifying case in the data is captured — including rare presentations no annotator would think to look for. Adding a condition means declaring its three code sets and re-running the extraction; the architecture, training recipe, and consensus mechanism do not change. And through all of it, a mark is a label on the scaffolding, never on the data.
Honest limits
The prototype's extraction ran over injected arcs, where every classification is clean by construction. Real claims will bring ambiguity — treatments that fit neither code set cleanly, tests repeated across years, coding habits that vary by insurer. What is demonstrated is that the extraction works end-to-end and trains the intended behavior; how gracefully the rules extend to real records belongs to the next phase.
5 · Pools and consensus
Why agreement is evidence.
PRISM never asks what one model thinks. The patient population is divided into disjoint pools; each pool trains exactly one model through both training rounds; and nothing ever crosses the boundary — no shared training examples, no shared weights, no shared steering adapters. The models never communicate, in training or at inference. That isolation is not a byproduct of the design; it is the design: a spurious pattern in one pool's data can mislead at most one vote, so when these models agree, that is independent convergence, not groupthink. N models firing is N separate measurements, never one measurement echoed N times.
The intuition
Five physicians who trained at different medical schools, practiced on different patient populations, and never discussed the case — all independently ordering the same test. Any one opinion might be pattern-matching on noise; the independent convergence is what carries weight. Because the models share nothing, the only thing that can make them agree systematically is a pattern that genuinely generalizes across populations.
The ensemble's entire output for a patient — an illustration
4 of 5 independent models surfaced the same test — a count of independent recognitions, never a probability.
And silence is not the mirror image: a quiet ensemble has said nothing at all. No consensus is never a negative recommendation.
Evaluation is built in, not bolted on
Because pools are disjoint, every patient is out-of-distribution for every model except the one trained on its own pool. Each inference run is therefore also a generalization test: four of the five models have never seen the patient — or any patient from its pool — and must recognize the pattern purely from what they learned elsewhere. That is why PRISM never sets aside a test set. Every example does double duty — training material for its own pool, evaluation material for the other four — and only those four out-of-distribution votes count as evidence. Nothing is held out, because everything is held out: from four-fifths of the ensemble, at all times.
What the 2026 prototype measured
The prototype used five pools of 5,000 synthetic patients each, made deliberately heterogeneous so the five trained models differ in substance. It ran all 3,250 phenotype examples through all five models; counting only out-of-distribution votes, firing rates tracked in-distribution rates almost exactly — the pattern was learned, not memorized.
False fires on no-signal controls (NOPE), 2026 synthetic prototype
Fire rate on control carriers whose records contain nothing that can legitimately predict their test — per model, and under unanimous consensus.
View the data
| reading | false-fire rate |
|---|---|
| any single model (noisy by design) | ~1.4% |
| unanimous 5-of-5 consensus | 0.07% |
Voting across independent models is the noise filter — a demonstrated result, not a hope. Both figures are flag rates on synthetic controls, never calibrated probabilities.
Honest limits
Every number above was measured on deliberately clean synthetic data against a fabricated condition. The prototype's clean data makes its rates an upper bound, not a forecast — what carries forward to real data is the frame itself, not the numbers. The full grid, the ablations, and every miss explained are on the evidence page.
From five toward a hundred
Five pools is a prototype count — enough to demonstrate the mechanism end to end, few enough for one person to build and run. The production vision scales the same architecture to on the order of 100 pools, making consensus finer-grained ("23 of 100" carries more shading than "2 of 5") without changing anything about how a single vote is produced. Where the consensus bar sits for a given condition would, in that vision, never be a machine-learning decision: thresholds calibrated per condition against historical outcomes, set and reviewed under medical oversight. The prototype set no thresholds; it reports raw agreement levels only. PRISM supplies the counts, physicians keep the judgment. The vision, marked as vision →
6 · Two training rounds
How each specialist is built.
Every PRISM model is built in two rounds, per pool, with nothing crossing pools in either.
Primary — the specialist factory
Full-parameter training of a general base model on one pool's complete patient histories — no instructions, no templates, just raw six-column tables and next-token prediction (a ~96k-token training context in the prototype round). The intent is over-specialization: by the end, continuing the table is all the model can do. And the primaries are fluent but not screeners — run without their steering adapters, the prototype's base models emitted the TEST code almost never: 7 fires in 1,200 runs (~0.6%). That near-silence is a feature; it lets the adapter-on/off comparison attribute everything the finished system does to round two.
Secondary — the steering round
A small LoRA adapter per pool, trained on that pool's own primary and never merged or shared. Where the primary installs competence, the secondary installs disposition: fire on the precursor pattern, stay quiet otherwise, surface the test early. The recipe that worked is plain supervised fine-tuning on the preferred continuations alone (as run in the prototype: 2 epochs, LoRA r32/α64, lr 3e-5, ~64k context; applied per request at full strength).
| aspect | primary round | secondary round |
|---|---|---|
| what trains | every parameter of the base model | a small LoRA adapter on the pool's own primary |
| material | the pool's complete patient histories | the pool's preferred continuations only |
| objective | next-token SFT — continued pre-training | next-token SFT on the preferred continuations |
| produces | a specialist that can only continue the table | the disposition: fire on signal, stay quiet otherwise, surface early |
| crosses pools | never | never |
Context sizes, epoch counts, and adapter settings are this round's configuration as actually run — recorded values, not constants of the method.
The lesson the prototype paid for
Preference training was the plan — the training data literally comes as preferred/dispreferred pairs — and it failed in a precise, instructive way: it ranked, but it would not emit. Under teacher forcing the preferred continuations scored excellent likelihoods; generating freely, the model never wrote them. Pure SFT on the preferred continuations alone worked near-perfectly — and the winning adapter's logged training metrics looked worse than runs that produced useless adapters. Anyone gating on train metrics would have discarded the adapter that worked. Hence the rule the whole project now runs on: gate on generation, never on train metrics. The honest boundary: this is one task, one dataset, one prototype — it does not indict preference methods in general. More for researchers →
Where the evidence lives
The mechanism is the easy part to explain.
The evidence is where to push.
The prototype proved the method works given a learnable precursor pattern; the next phase tests whether real conditions leave such patterns in real claims data. Everything quoted on this page — the grid, the consensus collapse, the ablations — is laid out with its limits in one place.
The evidence
The 2026 synthetic proof of concept: setup, the full firing grid, the ablations, every miss explained — and what none of it proves.
Read the results →The safeguards
Constructive-only, recall-not-prediction, anonymous by architecture — the posture this page kept pointing at, in depth.
The full posture →For researchers
The training rounds, evaluation without a hold-out, and the rank-vs-emit result, stated for a technical reader.
The researcher's view →The glossary
Pool, carrier, fire, silence, mark, arc — every term on this page, plainly defined.
Look something up →