How we read the medical check-up workflow, and built human–AI collaboration infrastructure on it

We build MCU CoPilot, the AI that turns a medical check-up clinic's raw data into finished, doctor-approved reports. Most of the work, though, was never the AI. It was reading how a check-up clinic actually runs, and then building a layer where the staff, the doctor, and the AI each do the part that's theirs — with clear lines between them, and a doctor deciding before anything goes out. Here's what we found in the workflow, and what we built on top of it.

Why we built it

A single corporate or institutional check-up can be hundreds of people — often thousands, sometimes tens of thousands. Each one moves through a dozen stations in a morning: bloods, imaging, ECG, vision, hearing, and every result lands in a different system or on paper. Someone then consolidates each person's data by hand, a doctor reviews every record, and reports go out one at a time. Depending on the size, getting all of it out the door takes days to weeks.

What struck me was where the time actually goes — and most of it isn't medicine. Clinic staff spend their evenings consolidating each person's results from separate systems and paper, assembling reports one at a time, and sending them out. The doctor, meanwhile, has to read and sign off on every single report — routine and serious alike — so the handful of cases that genuinely need a physician's judgment sit in the same queue as hundreds that don't. The constraint was never medical skill; it was that skill being spent on assembly and repetition. We built MCU CoPilot to take that load off both sides: the AI handles the consolidation and drafts a structured conclusion, so staff aren't assembling and mailing reports by hand, and the doctor reviews and decides instead of working through every record one by one — with attention freed for the cases that actually need it. Giving that time back is the obvious win. The one that matters more is what the time turns into: a patient who gets a clearer, more careful read, and a team that ends the day having done the work it trained for instead of data entry.

Not AI for its own sake

The easy version is to point a large model at the problem and call it solved. That makes a good demo and a bad product. The hard parts are buried in the workflow, and you only see them once you've done the work by hand.

A few of them. The same blood test shows up as HB in one lab's file, Hemoglobin in another, Hgb in a third — so the first thing MCU CoPilot does isn't reason about health, it's match fields by meaning and remember that mapping for that lab. Records have to be stitched across many files by one linking key, in a set order, or nothing aligns. And once a doctor validates a report, the data and the conclusion lock, so what the patient receives is exactly what was approved — not something that drifted afterward. None of this demos well. All of it is where reports actually go wrong.

There's no single definition of "normal"

This is the thing we couldn't have designed from a whiteboard. Every serious check-up institution has its own grading conventions and its own preferred clinical guidelines, built from years of experience and the population it serves. A reference range is the floor, not the answer.

So MCU CoPilot honors that instead of overriding it. An institution sets its own grading rules per field — its thresholds, its severity levels, even gender-specific ones — and the platform grades against those. An organization can describe its standards in plain language; a specific project can override the organization when one client needs something stricter. The guidelines an institution relies on are a controlled, reviewed set, not free text we guess at.

"Fit for work" is a judgment about a job, not a number

Corporate group check-ups make this concrete. Fitness isn't a medical fact; it's relative to the role. The same mildly reduced lung function might be a note for an office worker and "temporarily unfit" for someone on a factory line. A driver with partial color blindness is a different call than an analyst with the same result. Driving, heights, machinery, heavy physical work all get stricter handling — and which rule applies depends on the employer and the position.

We don't hard-code any of that. A clinic writes its fitness rules the way it would brief a new doctor: a short plain-language note on who's fit, who's fit with a note, who's temporarily unfit. A small agent inside MCU CoPilot turns that note into the exact instructions the report model follows — touching only what a customer is allowed to change, and leaving the medical reasoning to the platform. Early on we wrote those prompts like engineers; the clinics told us to write them like a clinic memo, not a textbook. They were right.

Under all of it sits a floor no one can configure away. A few hard clinical thresholds always force "temporarily unfit" and urgent follow-up, even if a client's own rule says everyone passes. You can tune the judgment. You can't tune away safety.

Why we test the way we do

If a doctor is going to sign it, "it looked right once" isn't enough. Run the same case twice through a model and you can get two answers — so we don't trust single runs. MCU CoPilot tests each clinical-fact decision many times and holds the report if any one of them drifts.

We turned that into a public benchmark: one fixed workflow, twelve foundation models, anonymized Indonesian check-up cases, across a repeat-stability lane and a broader risk lane. We don't score it on word-accuracy — that correlates poorly with whether a clinician would call an output safe. We score what matters in a clinic: does every conclusion trace to a finding, does it hold on a re-run, does it stay inside its safety boundaries, can a doctor review it quickly. The grader is never the model being graded, and the hardest cases go to a person. Ten of the twelve models cleared the first gate; nine cleared the harder one. We publish the method and the pass marks so any institution can run the same test on any vendor — us included.

Loop engineering, before it had a name

People are starting to call this "loop engineering." The idea is plain: you don't ship a prompt and walk away. You capture real cases, generate, gate the output against safety checks, find which layer failed, make the smallest fix, and lock it with a regression so an approved result can't quietly slip. Nothing changes the production path unless the gate stays green. Micromeet ran this loop on its clinical output before the phrase caught on, because in healthcare it isn't an optimization trick — it's the only honest way to change something a doctor depends on.

What deployment keeps teaching us

We've always treated this as frontier work, and the institutions we work with are at the frontier themselves — multi-site operators, corporate-health providers, diagnostic hubs running dozens of partner labs. They've stopped asking for faster reports; fast is assumed. They ask whether a conclusion traces back to the raw data, whether a doctor can see why a case was flagged, whether there's a second check before anything goes out.

That's where the product actually gets built. One taught us that "normal" is client- and role-specific. Another showed us the hard part isn't the model at all — it's that the same value arrives as 299 from one source and 299,000 from another, and a chunk of every large batch needs a sanity check before any AI conclusion is worth trusting. Each deployment becomes reusable knowledge, and the next one is better for it. And the report, it turns out, is only the first part of a clinic's day Micromeet has learned to do this way — the same principle reaches into the rest of the patient's journey, one careful step at a time. As one of them put it: a fragmented, multi-system workflow isn't a reason to wait — it's exactly where this is worth the most.

AI writes the draft. Doctors decide. The job is to make sure that by the time a doctor sees it, the draft has already passed the test you'd want it to — and that the hours we hand back aren't just saved but spent on better care, by people doing the work they trained for.