Healthcare revenue cycle
Kaiser claims automation means Epic Resolute, and the vendor list is shorter than it looks
People searching this typed eight names: UiPath, Automation Anywhere, Blue Prism, Akasa, Olive, Waystar, nThrive, FinThrive, next to Kaiser and Epic Resolute. Two of those names are the same company, one shut down in 2023, and the rest sit on different layers of the claim. Here is the honest map, verified June 2026, and the one piece of the work none of them actually do.
Direct answer (verified June 19, 2026)
Kaiser Permanente runs Epic (KP HealthConnect), so claims live in Epic Resolute, worked in the Hyperspace or Hyperdrive desktop client. Against that, the names collapse into a few real categories:
- UiPath, Automation Anywhere, Blue Prism: generic RPA that drives the Epic client by pixels or selectors, brittle over Citrix and on Epic upgrades.
- Akasa: mid-cycle generative AI for coding and prior auth, running inside Epic, not a clearinghouse or a bot.
- Waystar: a claims clearinghouse and payments platform that moves the 837 out and 835 back.
- Olive AI: shut down October 2023; its parts now sit inside Waystar, Humata Health, Availity, and BurstIQ.
- nThrive and FinThrive: one company. nThrive renamed to FinThrive in March 2022.
Mediar fills the slot none of them own: it drives the Resolute account screen directly through Windows accessibility APIs to work claim-edit and denial queues, without Epic API access and without breaking when the client changes.
The verified vendor table
Most guides on this present the names as a flat menu of eight live, comparable options. They are not comparable, and they are not all live. Each row below is checkable against the linked source.
| Name | What it actually is | Status (verified Jun 2026) | Drives the Resolute desktop client? |
|---|---|---|---|
| Epic Resolute | Epic’s billing application: HB, PB, SBO. The system of record, not an automation tool. | Active. Worked in Hyperspace / Hyperdrive. | It is the client |
| UiPath | General-purpose RPA. | Active. | By pixels / selectors, brittle |
| Automation Anywhere | General-purpose RPA. | Active. | By pixels / selectors, brittle |
| Blue Prism | General-purpose RPA (SS&C Blue Prism). | Active. | By pixels / selectors, brittle |
| Akasa | Mid-cycle generative AI: coding, prior auth, CDI, inside Epic. | Active. akasa.com | No, it works mid-cycle |
| Waystar | Claims clearinghouse and payments platform. | Active, public (Nasdaq: WAY, June 2024). source | No, it is the pipe between you and payers |
| Olive AI | Former RCM automation startup, once near a $4B valuation. | Shut down Oct 2023; assets at Waystar, Humata, Availity, BurstIQ. | No longer exists as a vendor |
| nThrive / FinThrive | One RCM software company, not two. | nThrive renamed FinThrive, Mar 2022. | No, it is RCM SaaS, not desktop execution |
| Mediar | AI agent that works the Resolute client via accessibility APIs. | Active. SOC 2 Type II, HIPAA. | Yes, by field name, not pixels |
Sources linked inline. Olive asset split also detailed at HIT Consultant.
Where each name sits in the claim lifecycle
The reason these tools are not really alternatives to each other is that they touch different steps. Read the lifecycle left to right and notice where the expensive manual typing actually happens: at the end, in the work queue.
A healthcare claim, and who touches each step
Register
Demographics + coverage entered in the Epic client
Eligibility / prior auth
Akasa, Olive's old prior-auth unit (now Humata)
Charge + code
Mid-cycle GenAI coding, e.g. Akasa, inside Epic
Scrub + submit 837
Clearinghouse: Waystar, Availity
Remit 835
Auto-posts; denials drop into Resolute work queues
Work the WQ
Biller types fixes into the Resolute desktop client
Resubmit + log
Back out through the clearinghouse
What “working a Resolute denial” actually involves
This is the work that costs biller time and the work no clearinghouse or coding model removes. None of these six steps has a claim-level API an outside tool can call; they all happen inside the Epic client a person logs into. That is the layer Mediar runs.
One denial work queue, account by account
- Open the claim-edit or denial work queue in the Epic client (Hyperspace or Hyperdrive)
- Read the remark or denial code off the remittance and the payer correspondence
- Pull the missing or wrong field from the chart, the coverage record, or a payer portal
- Type the correction into the Resolute account screen, not an API field
- Re-run claim edits, resolve the edit, and refile the 837
- Log the action and reason so the next biller and the auditor can follow it
Why this lands on the desktop client, not an integration
Epic is delivered to most billers as a published application over Citrix. When an RPA tool automates that screen by recording pixel coordinates or UI selectors, it is recording the position of a button on a remote desktop session. Epic ships quarterly upgrades, layouts move, and the Citrix-published window can render slightly differently from one session to the next. Each of those events can break a pixel or selector bot, which sends the workflow back to the Center of Excellence to be re-recorded. That maintenance tax is the quiet reason so many Epic RPA projects stall.
The usual fix is to stop driving the screen and build an Epic interface instead, which turns a quick automation into a months-long integration project, gated on Epic resources. For the high-volume, low-glamour work of clearing claim-edit and denial work queues, that is a heavy lift for a task a biller does in a minute.
Mediar reads the Resolute account screen the way a screen reader does: through the Windows accessibility tree, where fields are exposed by name. The agent types into a field called Service Date, not into a rectangle at coordinates (842, 318). When Epic moves that field or renames a button on an upgrade, the field is still called Service Date, so the run keeps going. There is no claim-level API in the loop because there does not need to be: the agent operates the same client the biller operates. The open-source Terminator SDK is the engine underneath, if your team wants to extend the workflows.
Mediar vs generic RPA, on the Resolute layer specifically
This is the comparison that actually decides a denial-automation project: not RPA brand against RPA brand, but how the agent reaches the Epic account screen and what happens when Epic changes.
| Feature | UiPath / Automation Anywhere / Blue Prism | Mediar |
|---|---|---|
| How it reaches the Resolute account screen | Records pixel coordinates or UI selectors on the Citrix-published client | Reads fields by name from the Windows accessibility tree, the same one a screen reader uses |
| What happens on an Epic quarterly upgrade or layout change | Selectors and coordinates shift, the bot breaks, the CoE re-records it | The field is still named Account or Service Date, so the run keeps going |
| Needs Epic API access or an interface build | Often pushed toward an Epic integration project to be reliable | No. It works the same client a biller works, no claim-level API required |
| Time to a working denial-WQ automation | Months of CoE project time per workflow is common | Days. The agent watches the workflow once, then runs it |
| Cost shape | Per-bot licensing plus implementation and maintenance | $0.75 per minute of runtime, no per-seat licensing; $10K program fee converts to credits |
Generic RPA is a fine fit for stable web and API-backed steps. The Resolute desktop client, delivered over Citrix and upgraded quarterly, is the case where pixel and selector approaches cost the most to maintain.
Where Mediar is not the answer
If your problem is moving claims to payers and getting remits back, that is a clearinghouse job, and Waystar or Availity already does it well. Mediar does not replace the 837 and 835 pipe. If your problem is assigning the right codes or handling prior authorization at scale, that is mid-cycle work, and a model like Akasa runs inside Epic for exactly that. Mediar does not replace the coding model.
Mediar is the execution layer for the part that is still a human typing into the Resolute client: working the edit and denial queues, correcting the field that triggered the rejection, refiling, and logging the trail. The three layers stack cleanly. Akasa suggests the code, Waystar moves the claim, and when a denial lands back in a Resolute work queue, Mediar works it instead of a biller.
See it work a Resolute denial queue with your own Epic build
Book a pilot and we will run a claim-edit or denial work queue through your Hyperspace or Hyperdrive client, no Epic API project required.
Frequently asked
Frequently asked questions
Does Kaiser Permanente run Epic, and what does that mean for claims automation?
Yes. Kaiser Permanente's enterprise EHR, KP HealthConnect, is built on Epic Systems software and hosts records for more than ten million members. That matters because in an Epic shop, claims live in Epic Resolute, Epic's revenue cycle billing application. Resolute splits into Hospital Billing (HB), Professional Billing (PB), and Single Billing Office (SBO). The expensive manual work is billers opening claim-edit and denial work queues in the Epic client and typing corrections account by account. So Kaiser-style claims automation is, concretely, automating the Resolute work queues in the Epic desktop client, not a generic claims API.
Is Olive AI still a claims automation vendor?
No. Olive AI, once valued near four billion dollars, shut down its business in October 2023. It sold its clearinghouse and patient access units to Waystar, its prior authorization unit to Humata Health, its utilization management unit to Availity, and its business intelligence to BurstIQ. If you are comparing Olive against the others as a live, standalone option, the comparison is out of date. The pieces of it now live inside other companies on the same list.
What is the difference between nThrive and FinThrive?
They are the same company. nThrive announced its name change to FinThrive in March 2022 as part of a rebrand. So listing nThrive and FinThrive as two separate vendors to evaluate double-counts one revenue cycle management company. FinThrive is the current name.
Can UiPath, Automation Anywhere, or Blue Prism automate Epic Resolute?
They can drive the Epic client, but it is the brittle part of those deployments. Epic is usually delivered to billers over Citrix, and pixel-matched or selector-based bots break when the published client shifts, when Epic ships a quarterly upgrade, or when a layout moves. To get reliable, teams often get pushed toward an Epic interface or API project, which turns a bot into a months-long Center of Excellence engagement. Mediar takes a different route: it reads Resolute fields by name from the Windows accessibility tree, so a renamed button or a moved field does not stop the run.
Where do Akasa and Waystar fit, and does Mediar replace them?
No, they are different layers. Akasa runs generative AI for mid-cycle work, coding, prior authorization, and clinical documentation, inside your existing Epic or Cerner without a rip and replace. Waystar is a claims clearinghouse and payments platform that moves the 837 out and the 835 back; it facilitated over six billion transactions in 2024 and went public on Nasdaq that June. Mediar is neither a coding model nor a clearinghouse. It is the desktop execution layer that works the Resolute account screen when a human would otherwise be typing. The three can coexist: Akasa suggests the code, Waystar moves the claim, Mediar works the denial queue.
What exactly is Epic Resolute, and which client do billers use?
Resolute is Epic's revenue cycle billing application, covering Hospital Billing, Professional Billing, and Single Billing Office. Billers reach it through Epic's user interface, historically Hyperspace, the long-standing Windows desktop client, and increasingly Hyperdrive, Epic's newer Chromium-based client. Both are desktop applications a person logs into and clicks through. There is no public claim-level API that lets an outside tool open and resolve a Resolute work queue, which is why the automation has to drive the client a biller drives.
Is Mediar HIPAA compliant and where does it run?
Mediar is SOC 2 Type II certified and HIPAA compliant, and deploys on-prem or in your cloud. Because it runs on the same workstation or virtual desktop a biller uses, the protected health information stays inside your environment; the agent operates the existing client rather than exporting data to a separate service.
Related reading
EMR billing workflow automation: the layer with no API
The denial-management mechanics this page references, worked end to end through the no-API billing client.
Cerner automation where no API reaches
The same accessibility-tree approach against the Cerner desktop client.
AI agents for legacy desktop systems with no API
Why the accessibility-API approach exists, across SAP, mainframes, and EHRs.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.