Autonomous agents fail for a boring reason: nobody can tell a good output from a bad one fast enough to stop trusting the system. In healthcare, that gap has a name. It's the verifier.
Here's a phrase you'll hear a lot this year: closed loop. A closed loop is a self-feeding workflow. The output of one run becomes the input of the next, with no human in between. Link a few of those together, point them at a goal, and you get a flywheel: a system that generates, measures its own results, and decides what to try next without waiting for you.
Coding agents already run this way. Frontier labs are building their whole operation this way. And the question nobody in healthcare has scoped out is: what happens when the flywheel starts spinning inside a health system that was never built to absorb it?
The ladder: pipeline, workflow, flywheel
Three rungs, and the difference between them matters.
A pipeline is a fixed sequence of steps. A cron job, an interface engine, plumbing. Whatever branching it has is mechanical. It exercises nothing you'd call judgment.
A workflow is a repeating sequence of decisions and actions with points where a human uses judgment. Prior auth, denials, intake. Strip the judgment out and a workflow collapses back into a pipeline.
A flywheel links many workflows and points them at an objective you defined once. A pipeline repeats. A flywheel steers, and the steering wheel is measurement. The system acts, measures what happened, and uses that measurement to pick the next move. It has three beats.
Generate
The agent produces an output: a draft appeal, a coded claim, a routed message.
Measure
Something checks the output against a definition of good. This is the verifier.
Decide
Based on the measurement, the system picks the next thing to try, then generates again.
There are two ways to close that loop. One works. One shows up in the incident report.
The wrong way is to pull out the human checkpoint and hope. That's how most "we deployed autonomous agents" stories start, and how the embarrassing ones end.
The right way is to replace the human checkpoint with a verifier: something that separates a good output from a bad one without a person reading every case. A reconciliation against known totals. A schema validation. A medical-necessity rule check. A denial-rate metric. The human judgment doesn't vanish. It gets encoded once into the verifier, rather than being spent by hand on every single run.
That's the whole thing. Loops don't close because a leader decides to trust the model. They close where verification got cheap, fast, and objective. Everywhere else, the human stays.
You're already running flywheels
If this sounds far off, look at how software gets written now. A modern coding agent doesn't just write code. It runs an experiment: write, run the tests, read the failures, rewrite, run the tests again. Nobody reviews iteration 3 of 7. The human reviews the final result. Generate, measure, decide, repeat. That's the shape, and it's running in production today.
It isn't a coding-only shape either. Picture a revenue-cycle loop. One workflow drafts appeals for denied claims. A second pulls the outcome from the payer: paid, denied, pended. A third reads that outcome and decides the next move, so appeals that win get reused and appeals that lose get rewritten. Wire the three together, and you have a system that gets better at overturning denials every week, with no human between iterations.
The reason it can run is the same reason coding could. The payer response is a verifier. The claim was paid, or it wasn't. The result is measured, not vibed.
Why did coding close the loop first? Because software spent 40 years building the verification it needed. Compilers, type systems, test suites, CI. When agents arrived, the verifier was already sitting there.
This is the principle that governs all of it: how easily an agent learns a task is proportional to how verifiable the task is. Coding was the most verifiable knowledge work on earth, so the loop closed there first. Healthcare has pockets of that same strength and large stretches where it's entirely missing.
Run the logic over your own building
Now ask the uncomfortable question. Which of your workflows has a test suite? Which one has anything close to it?
For most health systems, the honest answer is that the workflows have people. The coder who remembers how one plan bundles a code. The auth coordinator who knows which payer wants which attachment. The nurse who catches the lab value that's in range but wrong for this patient. Those people are the verification layer. They're also the coordination layer, the ones deciding what runs next and whether the whole effort is working.
Which means the human is the reason the flywheel can't spin yet. Remove them without building a verifier first, and you don't get autonomy. You get a loop that compounds its own mistakes at machine speed, in a setting where the errors land on patients.
So the work isn't "deploy more agents." It's building the verifier for each loop you want to close, and being honest about which loops have no verifier worth trusting.
Which loops to close first
Sort your workflows by one test: is the verifier stronger than the failure mode? Where checking is cheap and objective, and a wrong answer is cheap to catch, close the loop. Where "good" is a matter of clinical taste and a wrong answer is expensive, keep the human in it.
| Close early | Why the loop can spin |
|---|---|
| Sync and transform HL7/FHIR feeds, claims normalization, registry loads | The verifier is a schema. It matches, or it doesn't. Drift is detectable. Runs unattended for weeks. |
| Triage and routing inbound messages, referral faxes | A misroute is cheap and the next step catches it. Low blast radius, easy to measure. |
| Monitoring and reconciliation eligibility lapses, denial spikes, charge capture | The check is arithmetic. Totals reconcile, or they flag. The verifier is stronger than the miss. |
| Close last, if ever | Why the human stays |
|---|---|
| Clinical judgment calls diagnosis, dosing, care-plan changes | No cheap objective verifier exists, and the failure mode is a harmed patient. The loop stays open by design. |
| Taste-based external drafts patient-facing letters, sensitive messages | "Right tone for this person" can't be measured before it ships. A human owns the send. |
Notice this has nothing to do with how smart the model is. It's about whether you can check the work. A loop with a strong verifier closes with a mediocre model. A loop with no verifier stays open no matter how good the model gets.
The human moves up a level
People worry that closing loops writes clinicians and ops staff out of the picture. It does the opposite of that. It changes where they stand.
A workflow already moved the human from the middle to the edges. They set the parameters at the start and review the exceptions at the end. A flywheel moves them up again: off the individual outputs, off the coordination between workflows, and onto the verifier itself. Instead of checking 400 claims, the biller reviews the rule that checks the claims, and watches the 6 the rule couldn't resolve.
The judgment doesn't leave the building. It moves from being spent on every case to being encoded once, then supervised. That's a promotion, not a layoff.
The failure to plan for is quieter than job loss. It's compounding error and reward hacking. Because each run feeds into the next, a small mistake propagates rather than staying local. And a loop optimizing a measured number will happily game that number while missing the point, closing tickets that reopen, or "resolving" denials by writing them off. The defenses are known: regression checks, canary runs, drift detection, and a human whose actual job is to review the verifier, not rubber-stamp outputs.
Where ACTAVA fits
This is the work we do. The ACTAVA platform takes a healthcare workflow apart, decides where an agent acts and where a human gates the call, and runs it under governance you can see.
Two suites map straight onto the flywheel. χ-BENCH is agent simulation and benchmarking. It's how you build and validate the verifier: simulate the workflow, benchmark the agent against what good looks like, and catch a bad output before it reaches production. ACTAVA is also agentic governance and compliance. It's how you keep a human-in-the-loop on the verifier itself, with audit trails and role-based access, so the loop runs accountable instead of blind. Validate before autonomy, govern throughout. That order is the point.
You don't need us to start, though. Pick one workflow that runs every day. Write down how you'd know, automatically, whether the agent got it right. If you can answer that in one sentence, you have a loop worth closing. If you can't, you've found the verifier you need to build first, and that's the more valuable answer.
The flywheel is coming to healthcare on a schedule the labs set, not one you control. The organizations that do well won't be the ones with the best model. They'll be the ones who knew which loops they could actually check.
