The problem
Healthcare finance teams are drowning in data nobody can read.
Every Medicare and Medicaid finance team in the country receives critical payment data
from CMS in formats built for 1970s mainframe computers — fixed-width flat files with
cryptic field codes and no headers. Understanding this data requires a 200-page technical
manual and years of experience most teams don't have.
The people who knew how to decode these files are retiring. Junior staff don't know the
formats. And the workaround — paying consultants hundreds of dollars an hour to do what
should take minutes — doesn't scale.
CMS flat files nobody can parse
835s, 837s, RAPS return files, MOR files, PDE data, payment summaries — all arrive in COBOL-era formats that require specialized knowledge to interpret. That knowledge is walking out the door.
Weeks lost on data translation
Before a single dollar of analysis can happen, finance teams spend days or weeks just converting raw government files into something a human can read. Every bid season. Every reconciliation cycle.
Narrative work that takes forever
Budget variance memos, cost report sections, RADV audit responses — all written manually from scratch, every cycle, by analysts whose time is worth far more than document drafting.
No tools built for this domain
Generic BI tools don't know what PMPM means. General AI assistants don't know CMS codebooks. SOX controls, MBE reporting, payment adjustment reconciliation — this vocabulary doesn't exist in off-the-shelf software.
Why "zeebrafish"
Scientists picked zebrafish for one reason: transparency.
Zebrafish embryos are naturally see-through — scientists can watch a heart form and organs
develop in real time, no incision required. CMS data works the opposite way: fixed-width
flat files and undocumented field codes hide what's actually happening inside your
Medicare and Medicaid books. Zeebrafish AI makes it visible — upload the file CMS already
sent you, and see straight through to the numbers, the outliers, and the questions that
matter. No black box. No guesswork.
🔬
Built from inside the problem, not around it
Zeebrafish AI comes from a Kaiser Permanente National Medicare Finance analyst who
works inside these exact CMS files every day — backed by 15 years in enterprise
finance and data automation before that.
Read the full story →
The solution
Upload the file. Get the analysis. Move on.
Zeebrafish AI is an AI finance analyst that already knows Medicare and Medicaid data cold.
Upload any CMS flat file — and receive a plain-English explanation written at the level of
a senior Medicare finance analyst, structured exactly the way your team needs it.
📂
Upload your file
835, 837, MMR, RAPS, MOR, PPR/PRS, PDE, Part D, cost report, payment summary — any CMS format
⚡
AI analyzes it
Domain-trained on Medicare and Medicaid finance — no setup required
📄
Receive your report
Plain-English summary, key flags, and recommended next questions
✅
Act on it
Your team makes decisions — instead of decoding government data
See it in action
Raw CMS flat file in. Clean, human report out.
An illustrative example styled after a real MMR submission — this is what actually
changes when you upload a file.
📄
MMR_202607.txt
H12340260701202607TST000000000L000000AM195001
06037YYYY 001.234001.111000.987
0101302026070120260731000CF0000N
0000012345601H12340260701202607
TST000000001L000001AF19510101
06037YY 001.234001.111000.987
010102202607012026073100...
→
✉️
Your plain-English report
MMR, contract H1234 — July 2026
614 members, $612,340 net Part C/D capitation. Reconciled against the prior period
with 3 items flagged for review.
98.5% match rate
3 records need a second look — LIS flag mismatch, retro disenrollment
✓ 611 records passed formula validation clean
614Records analyzed
4 minTurnaround time
3Issues surfaced
Two purpose-built engines
One product line audits the payment. The other helps you earn it correctly in the first place.
Zeebrafish AI isn't one tool — it's two, aimed at two different moments in the Medicare
Advantage risk-adjustment and payment cycle. Jump to either one below, or keep scrolling to
see both in detail.
Introducing the Payment Integrity Engine
CMS runs MARx to calculate your payment. We run Shadow MARx to check it.
MARx is the CMS system that calculates what Medicare Advantage and Part D plans actually
get paid. It's the source of truth — and it's also a black box. The Payment Integrity
Engine is Zeebrafish's independent recomputation of that same payment logic, built directly
from CMS's own published formulas, so you're not just reading your MMR — you're auditing it.
MARx — CMS
The government's payment engine. Calculates what you're owed. Opaque, batch-run, and not built for finance teams to interrogate.
Shadow MARx — Zeebrafish
An independent, transparent recompute of the same calculation — beneficiary by beneficiary, always explainable.
We recompute your MMR payment independently and show you every beneficiary where actual does not equal expected.
Live today for MMR files, covering every CMS Part C and Part D payment scenario —
validated against 8 test scenarios, including deliberately broken ones, catching 8 for 8:
Standard risk-adjusted payment
Rebate-eligible plans
Basic premium plans
Hospice
ESRD
PACE
MSP reduction
Part D direct subsidy
Two edge cases the engine can't fully resolve from the MMR alone are disclosed in full,
by design, on our Trust &
data handling page — we'd rather flag what we can't verify than guess. The 835 has its
own independent Reconciliation Engine (below); PPR/PRS, MOR, and cost reports still get a
plain-English read today, with payment integrity checking for those next on the roadmap.
Now live: cross-file reconciliation
One file can tell you what happened. Two files can tell you what doesn't add up.
Most of the discrepancies that actually matter to a finance team aren't visible from
reading a single file — they only show up when you check what one CMS system says
against what a related system says about the same beneficiaries or the same claims.
Zeebrafish AI now runs that comparison automatically, tying two files together the way a
senior analyst would if they had time to check every row by hand.
MMR ↔ RAPS — enrollment vs. risk adjustment
For every beneficiary on your Monthly Membership Report, checks whether their diagnosis-cluster submission actually shows up in your RAPS return file — flagging an elevated-risk beneficiary with no matching RAPS record at all, a beneficiary whose every submitted diagnosis cluster came back with a CMS error code, or a HIC-level error on the RAPS side.
837 ↔ 835 — claims submitted vs. claims paid
Matches every claim on your 837 professional claim file to its remittance on the paired 835 by patient control number, verifies the billed charge ties out, and flags claims that were submitted but never paid, plus remittances that don't trace back to any claim in the file you sent.
Validated against synthetic fixtures with deliberate breaks built into both checks —
currently catching 14 for 14.
Every report now answers a second question — not just what's wrong this month, but whether it's getting better or worse, and whether you've seen it before.
Every supported submission is also logged — contract, file type, period, match rate, and
total flagged dollars — so the next file for the same plan doesn't start from zero.
Zeebrafish AI compares this month against that plan's own history and calls out whether
things are trending better or worse, and which discrepancy types keep recurring
month after month.
Introducing the HCC Priority Engine
CMS only pays for diagnoses that actually get coded. DxRadar reads the chart first, so nothing gets missed.
The CMS-HCC risk-adjustment model only pays for conditions that are documented and
submitted as a code — a real, well-managed diagnosis that never makes it out of a clinical
note earns nothing. The HCC Priority Engine reads a clinical note the way a certified
risk-adjustment coder would: pulling out every diagnosis mentioned, mapping it against the
same ICD-10-to-HCC crosswalk and hierarchy logic CMS uses in the V28 model, and ranking the
findings by reference weight — so your coding and CDI teams know exactly which diagnoses
matter most before the chart is ever finalized.
Manual chart review
A coder or physician reads the full note and manually cross-references every diagnosis against the CMS-HCC crosswalk from memory — easy to miss a lower-frequency but high-weight code, like a metastatic site or an HIV diagnosis buried in a long note.
HCC Priority Engine — Zeebrafish
Every diagnosis mention is extracted, mapped to the V28 crosswalk, checked against hierarchy rules, and ranked by reference weight in minutes — with the exact ICD-10 codes behind every finding shown for the coder to confirm.
We don't decide what's true in the chart. We surface every HCC-eligible diagnosis the model would score — ranked, sourced, and ready for a human coder to confirm.
Live today, covering:
ICD-10 → CMS-HCC V28 mapping
Hierarchy suppression
RAF reference-weight ranking
Closest-match lookup
PDF · DOCX · TXT notes
An illustrative example based on a synthetic test note — this is what the engine actually
returns when it runs end to end.
📝
oncology_consult_note.txt
ONCOLOGY CONSULT — FOLLOW-UP
Patient: 58F, established patient, referred for ongoing management.
...
Assessment: Metastatic breast cancer (invasive ductal carcinoma), now with pulmonary and hepatic metastases confirmed on CT chest/abdomen. HIV disease, on ART (bictegravir/emtricitabine/tenofovir alafenamide), most recent viral load undetectable, CD4 stable. Hypertension, well-controlled on lisinopril 10mg daily. Plan: continue chemotherapy per oncology...
→
🩺
Your HCC coding priority review
Draft for coder confirmation — 5 codes reviewed
2 diagnoses prioritized by CMS-HCC V28 reference weight, 1 suppressed by hierarchy, 1 code flagged for a closer look.
① HCC17 — Cancer, metastatic (ref. weight 4.209)
From C78.7 (liver) + C78.00 (lung) — confirm both are physician-documented in the chart.
② HCC1 — HIV/AIDS (ref. weight 0.301)
From B20 — confirm this reflects an established diagnosis, not just an exposure or inconclusive test.
✓ Breast cancer (HCC23) correctly suppressed — HCC17 outranks it under V28 hierarchy
Also flagged: I10 (hypertension) doesn't map to any payable HCC under V28 — expected, not
an error. Hypertension alone isn't risk-adjustable in this model, but the engine surfaces
it rather than silently dropping it, so a coder can confirm that's correct.
5ICD-10 codes reviewed
2Prioritized HCC findings
< 3 minTurnaround time
📚
Where these numbers actually come from
The ICD-10-to-HCC crosswalk, hierarchy-suppression rules, and reference weights are
loaded directly from CMS's own published 2024 CMS-HCC Model V28 files — the same tables
CMS uses to compute risk scores — not approximated or memorized by an AI model. Claude's
only job in this pipeline is reading the free-text note and identifying which diagnoses
are mentioned; everything after that — the mapping, the hierarchy check, and the ranking
— is deterministic code, run the same way every time.
What it can't do yet
No OCR yet
A scanned or image-only PDF note comes back with little or no extracted text. Typed, digital notes (PDF, DOCX, or TXT) work best today.
Diagnosis extraction is AI-read, not byte-parsed
Unlike the MMR parser's deterministic, byte-level decoding, pulling diagnoses out of free text depends on an AI model reading the note — ambiguous phrasing or heavy abbreviation can cause a diagnosis to be missed or misread. Everything after extraction — mapping, hierarchy, ranking — is fully deterministic.
Reference weights, not your final RAF
The weights shown are CMS's published model reference weights. A beneficiary's actual risk-adjustment factor also depends on demographic and enrollment-segment adjustments this engine doesn't yet apply — treat the ranking as a coding-priority signal, not a payment number.
Only checks the ~7,770 codes in the V28 crosswalk
A code that comes back "not recognized" may simply be non-risk-adjustable, or it may be a typo or documentation issue — the engine flags it either way, but a coder makes the final call.
Doesn't check MEAT documentation support
The engine confirms a diagnosis is mentioned and how it would map — it doesn't verify the note meets CMS's specificity/MEAT (Monitor, Evaluate, Assess, Treat) standard required to actually substantiate the code on audit.
No logged audit record yet
Unlike the MMR pipeline, HCC submissions aren't yet written to a logged, timestamped record — that wiring is planned, not yet built.
What's next
OCR for scanned and image-based notes
So a photographed or scanned chart page works the same as a typed one.
MEAT-criteria documentation checks
Flag diagnoses that are mentioned but under-documented for CMS's specificity standard, before they ever reach an auditor.
Personalized RAF computation
Layer in a beneficiary's actual demographic and enrollment-segment data, so the ranking becomes an estimated payment impact — not just a reference weight.
Multi-note and full-encounter-history ingestion
Review a full chart or an entire year of encounters at once, instead of one note per submission.
Direct EHR integration
So notes don't need to be manually exported and uploaded at all.
As with every Zeebrafish AI product, please test the HCC Priority Engine with synthetic or
de-identified clinical notes only during this private beta — unstructured notes carry more
PHI risk than a structured CMS file, and we're not yet HIPAA-certified end-to-end across
every vendor in our pipeline. Full detail on our Trust & data handling page.
Built to be checked, not just trusted
The three questions every finance team asks before they trust a number.
"Is this calculation CMS accurate?"
The Payment Integrity Engine recomputes every beneficiary's expected payment straight from CMS's own published formulas in the MAPD Plan Communications User Guide (PCUG v19.3) — not an approximation. It's validated against 8 test scenarios, including deliberately broken ones, and correctly catches every injected error, like a $50 overpayment and a broken Part D sum.
"Can I audit this?"
Every submission gets a logged, timestamped audit record. For MMR files, every field is parsed deterministically byte-by-byte against the real CMS record layout — no black-box AI guess on the numbers, only on the narrative around them.
"Where did this number come from?"
Every flagged discrepancy traces back to a specific field, byte position, and CMS formula — not a model's paraphrase. Anything the engine can't fully verify from the file alone is disclosed by name, not glossed over. Full detail on our
Trust & data handling page.
Why Zeebrafish AI is different
Built from the inside — not reverse-engineered from the outside.
Domain expertise baked in — not bolted on
Built by a Medicare finance analyst from Kaiser Permanente's National Medicare Finance division. The product understands MMR and PPR/PRS reconciliation, HCC risk adjustment, V24/V28 model transitions, Part D payment analytics, SOX control processes, and CMS/MBE reporting because it was built by someone who works with this data daily.
Analysis, not just translation
Anyone can summarize a file. Zeebrafish AI flags what's financially significant, identifies anomalies, and surfaces the questions your team should be asking — and for MMR files, independently recomputes the payment itself via the Payment Integrity Engine above.
Works with whatever you have today
No new data warehouse. No IT implementation. No rip-and-replace of existing systems. You upload the file CMS already sent you and get your answer.
Careful with sensitive data by design
Every submission gets a full audit trail. We're upfront that we're currently in private beta, tested with synthetic files and Public Use Files — and working toward signed BAAs across every vendor in our pipeline before we handle real PHI. Full detail on our
data handling page.
"
We have three people whose entire job is converting CMS flat files into something our
finance team can read. It takes two weeks every quarter. If we could get that time
back, we'd have a completely different capacity for actual financial analysis.
— VP Finance, mid-size Medicare Advantage plan
Who it's for
Any team that touches CMS data.
- Medicare Advantage plan finance teams managing bids, RADV, and risk adjustment reconciliation
- Medicaid MCO finance teams handling FMAP, encounter data, and state reporting
- Medicare payment reconciliation and reporting teams at large integrated health systems
- Hospital finance teams preparing Medicare cost reports and DSH calculations
- ACO and value-based care finance teams managing CMS benchmarks and shared savings
- Finance analysts who regularly receive CMS flat files and spend days decoding them
Free during private beta
See it work on your actual files.
Upload a real file — 835, MMR, MOR, PPR/PRS, payment summary, cost report, or a
clinical note for HCC coding review — and receive a full plain-English analysis
within minutes. No commitment. No setup.
What you'll receive:
File type identification · Key financial summary · Anomaly flags · Payment integrity check (MMR files) · HCC coding priority review (clinical notes) · Recommended next questions · Full audit log entry
Upload your file below ↓
Try it now
Upload a file — see straight through it.
Zeebrafish AI produces a first-pass analyst read to accelerate your team's review — it
is not a substitute for a CMS-certified reconciliation, audit opinion, or legal/compliance
sign-off.