Payer Underpayment Detection: AI Agent vs Tool vs Manual

By Jude Lee · · Comparison

Office manager and biller comparing remittance advice to a contracted fee schedule on a computer screen in a small practice back office

The revenue leak nobody owns

Every paid claim carries a quiet question: did the payer pay the contracted rate? The answer lives in the electronic remittance advice — the X12 835 transaction adopted under HIPAA Administrative Simplification, which CMS documents on its Administrative Simplification pages — and in your signed fee schedules, which typically sit in a PDF folder nobody has opened since credentialing.

The gap between those two things is where underpayments hide: a line paid at an outdated fee schedule, a bundled procedure that shouldn’t have been bundled, a downcoded level of service, a “silent PPO” discount routed through a network you didn’t contract with, or a contractual adjustment posted automatically because the posting rules said to write it off.

That last one is the real problem. Most practices auto-post contractual adjustments without ever comparing the allowed amount to the contracted amount. The write-off happens, the claim closes, and the variance never surfaces. This is a different job from denial triage — nothing was denied. The claim looks paid.

Why this is suddenly a vendor category

As of 2026, agentic revenue-cycle tooling is being funded and marketed hard. Several vendors now pitch AI agents that work billing and practice-management tasks end to end, and the health-IT trade press has covered a run of large funding rounds in the category. Treat that as a market signal, not a product recommendation: capital flow tells you where attention is going, not whether a given tool will reconcile your Delta Dental or Blue Cross fee schedule correctly. Payers are automating their side too, which is why understanding how payer-side AI changes your workflow matters before you buy anything.

Option one: the spreadsheet spot-check

A biller pulls a sample of paid claims for one payer, looks up the contracted rate for each CPT or CDT code, and eyeballs the variance.

It costs nothing, it works, and it is how most small practices discover their first underpayment. The limits are obvious: it samples rather than checks everything, it degrades the moment fee schedules update mid-year, and it competes for time with work that has a deadline attached. Spreadsheet review is the right answer if you have two or three payer contracts and low code volume. It’s a periodic audit, not a system.

Option two: contract analytics inside your existing stack

Practice management and RCM platforms — athenahealth, Tebra, AdvancedMD, eClinicalWorks and comparable systems among them — commonly offer contract or fee-schedule modules that flag underpaid lines automatically. Clearinghouses such as Waystar and Availity, along with standalone contract-management vendors, sell similar capability, and expected-reimbursement or variance reporting is sometimes already bundled into a plan you’re paying for. Ask before you buy a second tool, and check current product documentation — feature names and tiers change often.

The honest pitch: this is deterministic math, already wired into your posting workflow, running on data the vendor holds under a business associate agreement. If it exists in your stack and works, it’s usually the best first move.

The honest limits: someone still has to load and maintain every fee schedule accurately, and that work is tedious and easy to get wrong. Off-the-shelf modules tend to handle clean fee-for-service comparisons well and struggle with the messy cases — carve-outs, percent-of-Medicare terms tied to a locality, bundling language buried in an amendment.

Option three: a custom AI agent over your own data

This is where language models earn their keep, and it’s worth being precise about why. Claude, ChatGPT and their peers are general-purpose large language models — generative AI, not billing software. They are unreliable at arithmetic you care about and genuinely good at reading unstructured documents and explaining discrepancies in plain English.

So don’t ask a model to calculate variance. Ask it to do the two jobs around the calculation:

  1. Read the contract. Turn a scanned amendment into structured fee-schedule rows: code, rate, effective date, modifier rules, carve-outs. A human verifies the extraction before it becomes the source of truth.
  2. Explain and act on the variance. Given a flagged line, the CARC and RARC codes on the remit, and the contract language, draft the appeal, assemble supporting documentation, and queue it for approval.

Know where this step fails, because it fails quietly. OCR on a scanned percent-of-Medicare table misreads columns and effective dates — a 110% row becomes 10%, or last year’s locality sticks. Modifier and carve-out logic gets silently flattened: the model produces one clean rate per code and drops the “except when billed with modifier 26” sentence that changes everything. And appeal drafts can cite contract sections that don’t exist, or paraphrase a clause into language the payer will happily reject. Your reviewer should be checking those three things specifically, not skimming for tone.

The connective tissue is MCP — the Model Context Protocol, an open standard for giving an AI assistant governed, permissioned access to specific systems and data. A custom MCP server over your practice-management data can expose exactly three read-only tools: get_paid_lines(payer, date_range), get_contracted_rate(payer, code, modifier, effective_date), and get_remit_codes(claim_id). Nothing else. The build pattern is covered in more depth in our HIPAA-aware guide to connecting Claude to an EHR via MCP.

The ongoing cost is the part that gets under-priced. Every contract year brings fee schedules that must be re-extracted and re-verified. Your MCP server breaks when the PM vendor changes its API or auth model. And somebody has to own the thing when the developer who built it moves on — so put the repository, credentials, and documentation in your accounts on day one, and budget maintenance hours the same way you budget a subscription.

Off-the-shelf contract analytics
Fastest to turn on if your platform already has it. Deterministic variance math you can audit. Vendor maintains it. Weak on unstructured contract amendments and on drafting the appeal. Costs are predictable, usually per-provider or per-claim.
Custom AI agent + MCP server
Handles messy contracts, multi-payer comparison, and appeal drafting in one flow. Requires a developer, a BAA with your model provider, annual fee-schedule refreshes, and someone accountable for maintenance. Worth it with many contracts, complex bundling, or an appeals backlog nobody is working.
Detection is the easy half. The expensive half is the letter, the phone call, and the follow-up weeks later.

Building it, if you build it

  1. Digitize one payer contract first

    Pick your highest-volume payer. Extract the fee schedule into structured rows with a human verifying every line. If this is too painful to finish for one payer, you are not ready to automate ten.

  2. Expose a minimum-necessary MCP server

    Read-only tools returning paid lines, contracted rates, and remit codes — scoped to the specific fields the job needs. The HHS Office for Civil Rights treats minimum necessary as a core HIPAA Privacy Rule requirement; your privacy officer should sign off on the field list.

  3. Write the variance check as code, not as a prompt

    Deterministic subtraction, in software, with a tolerance threshold you set. The model never does the math.

  4. Package the appeal as a reusable skill

    A skill is a packaged set of instructions that makes the assistant do the job the same way every time: which clause to cite, which attachments to include, which portal or address to use. One skill per payer beats one giant prompt.

  5. Keep approval human

    Every appeal gets read by a biller before it leaves. Log what the agent proposed, what the human changed, and what the payer ultimately paid.

Software finds the variance; leverage collects it. Many states have prompt-pay statutes governing how quickly and completely payers must settle clean claims — terms vary by state and plan type, so confirm yours with your state insurance department or healthcare counsel. Your contract’s own dispute-resolution, audit, and appeal provisions are the other lever, and citing them by section in writing often moves a file that portal messages don’t. Timely-filing and appeal windows are payer- and state-specific; check the actual contract rather than assuming a standard clock.

Modeling the payback without making up numbers

Don’t accept anyone’s headline recovery figure, including ours — we don’t have one. Build your own estimate from things you can look up:

Allowed − contracted
Per-line variance: the only number that matters
Lines × variance rate × avg gap
Monthly exposure estimate, using your own sample
Hours × loaded hourly rate
Cost of the appeal work you're adding

Run a manual audit on 100 paid lines from one payer before you buy anything. If the variance rate is near zero, stop — you’ve saved yourself a purchase. If it isn’t, you have a defensible input: exposure per month, minus appeal labor, minus tool cost and maintenance, times whatever collection rate you think is realistic on appeals. Plug in your own numbers and be pessimistic about that rate.

The full picture includes what the spreadsheet misses: hours a biller redirects from manual reconciliation to aged A/R, adjustments that stop being written off silently, and leverage at renegotiation when you can show a payer a documented pattern.

Two recurring questions about automation limits

The so-called “30% rule” in AI is not a formal standard, a regulation, or a published finding — it’s an informal rule of thumb circulating in several versions, most commonly the idea that you should fully automate only the narrow slice of a workflow you can verify and keep a human on the rest. Useful mental model, not a benchmark. Our heuristic, stated plainly as opinion: automate detection and drafting, never automate the decision to accept a payment or send a dispute.

There is also no single best AI for a medical practice. The right tool is job-specific — a scribe for documentation, a rules engine for claim scrubbing, an agent for multi-step chart and remit work. We break that down job by job in our buyer’s map for practice AI. For underpayment detection specifically, the usual order is: check whether your PM system or clearinghouse already does it, then consider a custom agent, and keep the spreadsheet if your contract count is small.

When to skip all of this

If you’re primarily capitated, if you have two payers, or if your billing is outsourced under a contract that already includes underpayment review, this may not be your highest-value automation project. Verify what your RCM vendor actually checks — many reconcile denials but not contractual variance — and ask for a sample variance report before assuming it’s covered.

Not sure where to start?

Get a free automation audit: we map your scheduling, intake, insurance, billing, and patient communication and show you what's worth automating — before you spend a dollar.

Get a free automation audit

Related guides