Insurance Claims Are Still Processed by Hand in 2025. A Computer Use Agent Should Be Doing That.
Cigna's doctors spent an average of 1.2 seconds reviewing each insurance claim before rejecting it. One point two seconds. That's not a typo, and it's not a conspiracy theory. It's what ProPublica found after investigating the company's PXDX algorithm, which helped deny over 300,000 claims in just two months. So when people ask whether AI is ready to automate insurance claims, my answer is: it already is automating them. The question is whether it's doing it right. Right now, the industry is split between two terrible extremes. On one side, you have insurers using opaque algorithms to rubber-stamp denials at machine speed, dodging legal scrutiny and generating class-action lawsuits. On the other side, you have insurance operations teams still manually copying policy numbers from one system into another, in 2025, because their 'automation' is a stack of brittle RPA bots held together with prayers and vendor contracts. Both are indefensible. And both are fixable with a real computer use agent.
The Numbers Are Actually Embarrassing
Let's put some concrete weight on this problem. Insurance fraud alone costs the industry $308 billion annually, according to Deloitte. A significant chunk of that slips through because manual review doesn't scale. Claims adjusters, the actual humans doing this work, spend a staggering portion of their day on tasks a machine could handle: pulling policy data, cross-referencing coverage terms, logging notes into a CMS, sending templated follow-up emails, and re-entering the same information across three different legacy systems that don't talk to each other. RPA can process insurance claims up to 75% faster than manual processing, per Flobotics research citing industry data. Automation can take over 37% of tasks in insurance, per Accenture. Deloitte puts potential claims processing cost reductions at 30% or more with proper AI implementation. And yet, most carriers are still nowhere close to capturing that. Why? Because the tools they're using are either too dumb, too rigid, or too dangerous.
RPA Was Never the Answer. It Was a Duct Tape Fix.
The insurance industry fell hard for robotic process automation in the 2010s. UiPath, Automation Anywhere, Blue Prism, all promising to automate the repetitive stuff. And to be fair, RPA works fine when nothing ever changes. The problem is that everything changes. A vendor updates their web portal. A state regulator changes a form field. A new document type shows up in a claim. And suddenly your carefully scripted bot is clicking on empty air and throwing errors at 2am. Someone has to go fix it manually. RPA bots are essentially recorded macros with delusions of grandeur. They can't read an ambiguous PDF, they can't navigate an unexpected pop-up, they can't decide what to do when the login page looks different than it did last Tuesday. They require constant maintenance, they need pixel-perfect UI stability, and they don't generalize at all. The moment something breaks their script, they stop. That's not automation. That's a fragile crutch that creates its own category of IT overhead. The insurance companies that went all-in on RPA five years ago are now quietly trying to figure out how to replace it without admitting they wasted millions.
Cigna's doctors spent an average of 1.2 seconds per claim review using their PXDX algorithm, denying over 300,000 claims in two months. UnitedHealth now faces a class-action lawsuit for similar AI-driven denials. This is what happens when you automate the outcome without automating the actual work.
The Lawsuit Problem Nobody Wants to Talk About
Here's the irony that should make every insurance executive uncomfortable. The industry's AI story right now has two chapters. Chapter one: carriers use opaque models to deny claims faster than any human could read them, generating massive headlines, congressional investigations, and class-action suits from UnitedHealth to Cigna to Humana. Chapter two: the same carriers still have back-office teams manually processing legitimate claims because they're scared to touch the actual workflow automation. They automated the denial. They didn't automate the work. That's backwards. The scandal isn't that AI touched insurance claims. The scandal is that AI was used to rubber-stamp rejections while the legitimate processing work, the document extraction, the system lookups, the data entry, the status updates, stayed manual. A proper computer use agent doesn't make coverage decisions. It handles the operational grind: pulling the claim from the intake queue, reading the attached documents, cross-referencing the policy in the system, flagging discrepancies for a human adjuster, and logging everything. That's not controversial. That's just not wasting people's time.
What a Real Computer Use Agent Actually Does Here
A genuine AI computer use agent doesn't call an API and call it automation. It actually uses the computer the way a human would, navigating real desktop apps, real browser-based claims portals, real legacy systems that were never designed with any API in mind. It reads PDFs. It fills out forms. It opens the policy management system, finds the right record, checks coverage limits, and pastes the relevant data into the claims workflow. It does this without breaking when the UI shifts slightly, because it's not following a brittle recorded script. It's actually understanding what it's looking at. For insurance specifically, this matters enormously. Most carriers run on legacy platforms. ClaimCenter, Guidewire, homegrown systems from 2004. Nobody has a clean API layer over all of it. RPA was supposed to bridge that gap and mostly failed. A computer-using AI agent bridges it the same way a new human employee would: by looking at the screen and figuring it out. The difference is it doesn't need two weeks of onboarding, it doesn't get tired, and it can run in parallel across dozens of claims simultaneously.
Why Coasty Is the One Worth Paying Attention To
I've looked at what's actually available in the computer use agent space right now, and the performance gap is real. Coasty sits at 82% on OSWorld, the standard benchmark for computer-using AI agents, and nothing else is close. That's not marketing copy. OSWorld tests agents on real, open-ended computer tasks across actual operating environments, the kind of messy, unpredictable work that breaks every rule-based system ever built. At 82%, Coasty is handling the hard stuff. For insurance operations, what that means practically is this: Coasty controls real desktops, real browsers, and real terminals. It's not a wrapper around a chatbot. It can open your claims management system, read an uploaded FNOL document, look up the associated policy, check coverage, and populate the adjuster's workflow, all without needing a custom API integration or a team of RPA developers maintaining brittle scripts. It runs in cloud VMs, supports agent swarms for parallel execution across high claim volumes, and has a free tier so you can actually test it before committing. That last part matters because the insurance industry has been burned enough times by automation vendors promising the world and delivering a bot that breaks on Tuesdays.
The insurance industry is going to automate claims processing. That's not a prediction, it's already happening. The only question is whether it happens intelligently or whether carriers keep choosing between two bad options: opaque denial algorithms that generate lawsuits, and fragile RPA that generates IT tickets. Real computer use automation, the kind where an AI agent actually operates the software, reads the documents, navigates the systems, and does the work, is the version that actually helps. It reduces the manual burden on adjusters, speeds up legitimate claims, and doesn't require anyone to rebuild their entire tech stack to make it work. If you're in insurance operations and you're still watching humans copy-paste data between systems in 2025, that's not a staffing problem. That's a tool problem. Fix the tool. Start at coasty.ai.