AI Medical Coding: Autonomous vs CAC vs Human Coders

By Jude Lee · · Comparison

Billing specialist and office manager reviewing coded claims on a monitor in a small practice back office

Autonomous coding is having a moment. Several startups in the autonomous-coding category have raised funding over the past year, and nearly every practice-management vendor now has a coding assist feature on the roadmap. That’s real momentum — but the category was built for health systems coding tens of thousands of encounters a month. If you run a five-provider primary care group, a two-chair dental office, or a behavioral-health practice billing time-based psychotherapy sessions, the question isn’t “should we go autonomous.” It’s which parts of coding are actually mechanical, and what do I do with the rest?

What each of the three approaches actually does

Computer-assisted coding (CAC) reads the note and suggests codes, usually inside the EHR. Older CAC used NLP and rules dictionaries; newer versions use large language models. Either way the human coder or provider accepts, edits, or rejects. It’s a suggestion engine — the workflow shape doesn’t change.

Autonomous coding goes further: for encounter types the vendor has trained and validated on (radiology reads, ED facility coding, straightforward office visits), the system assigns codes and pushes the claim without a coder touching it, routing only low-confidence cases to a human. The economics come from volume and sameness.

A custom coding agent is the newer option: an AI assistant like Claude, connected to your practice-management system and document store through MCP, running a defined coding review task and writing its output to a worklist a human clears. It isn’t a coding product. It’s your process, packaged.

Where the human coder is still the cheapest option

Coding isn’t one job. Assigning an ICD-10 code from a documented diagnosis is close to a lookup task. Deciding whether an office visit’s documentation supports the level billed — under the AMA’s CPT framework, where office E/M levels are selected by medical decision making or total time — is a judgment task that leans on documentation the model may not have. Sequencing diagnoses, applying modifiers, and knowing that one payer wants a different code combination than another is institutional knowledge.

Dental is its own case. CDT coding for a crown, an extraction, or scaling and root planing frequently turns on attachments and narratives — radiographs, perio charting, a written justification — that the payer reviews alongside the code. Autonomous engines built around CPT office visits generally aren’t designed for that attachment-plus-narrative pattern, so a dental practice evaluating “AI coding” should ask specifically what the tool does with the supporting documentation, not just the code.

On small panels, a good coder or biller who knows your providers’ documentation habits is often faster and more accurate than any tool, because they already know that Dr. R never documents time and Dr. K over-documents everything. AI helps that person read faster. It rarely replaces them at your volume.

If your coding backlog is caused by clinicians not documenting what they did, an AI coder will confidently code what isn’t there. Fix the note before you automate the code.

The agentic version, concretely

Here’s what a scoped coding agent looks like for a practice that already has a biller. Nothing about it is magic; it’s a reading assistant with governed access and a fixed procedure.

  1. Give it governed, minimum-necessary access

    An MCP server exposes exactly the tools the agent needs: get_encounter_note(id), get_patient_coverage(id), get_payer_rules(payer_id), write_coding_recommendation(...). No blanket database read, no ability to submit a claim. Any vendor whose model touches PHI needs a signed BAA — see HHS Office for Civil Rights guidance on business associates — and access logging you can actually pull during an audit.

  2. Define the coding pass as a skill

    A skill is a reusable instruction package that makes the agent do the job the same way every run: pull the note, extract documented diagnoses and procedures, map to candidate ICD-10 and CPT/CDT codes, check the documented elements against your internal level-selection checklist, flag missing modifiers, and state a confidence level with the exact quoted sentence supporting each code. Same output shape every time — which is what makes review fast and audits survivable.

  3. Write to a worklist, not to the clearinghouse

    Output lands in a review queue: recommended codes, supporting quotes, flags, and a “documentation insufficient” reason where relevant. Your biller clears it. Encounters where the agent is confident and the note is clean take seconds; the messy ones get the attention they deserve.

  4. Close the loop with denials

    Feed denial and rework outcomes back into the skill each quarter. Coding rules drift, payer edits drift, and your providers’ documentation drifts. This is the same feedback discipline that makes denial triage work.

Be clear-eyed about how this path fails. A language model can produce a supporting “quote” that isn’t verbatim in the note, which is exactly the artifact an auditor will pull, so the reviewer has to spot-check quotes against the chart rather than trusting them. Skills drift silently after each annual CPT and ICD-10-CM update unless someone re-tests them against the new code set. And when a mis-scoped tool or a stale instruction produces a wrong recommendation, there is no vendor on the hook — the exposure is entirely yours. That means a named owner for the agent, indefinitely. If nobody in your practice or your build partner is accountable for it in month 18, don’t start.

Comparing the two builds you’d realistically choose between

Vendor autonomous / CAC module
Fastest to switch on, validated against a vendor’s own dataset, priced per encounter or per provider. Coding logic is a black box you can’t inspect or tune. Works best when your specialty and payer mix match what the vendor built for. Support, code-set updates, and fixes are someone else’s job — a real advantage for a two-person back office.
Custom MCP-connected coding agent
You control the logic, the prompts, the confidence thresholds, and what data ever leaves your walls. Fits multi-specialty or odd payer mixes that off-the-shelf tools handle badly. Costs engineering time up front plus permanent ownership: annual code-set retesting, prompt maintenance, and someone accountable when output is wrong. Only worth it if coding volume and variation are high enough that a generic tool keeps getting your cases wrong.

The honest middle path: buy the module, keep a human reviewer, and build custom only for the specific slice your vendor doesn’t cover. That’s the same reasoning laid out in our broader take on custom versus off-the-shelf healthcare automation.

Model the money yourself — don’t accept a vendor’s headline

Don’t start from a savings percentage. Start from your own numbers. As a purely hypothetical illustration: say 400 encounters a month, 6 minutes per chart today, and 2 minutes when a structured recommendation is already in front of the reviewer. Measure your own baseline over two weeks before you trust anyone’s figure — including this one.

40 hrs
Baseline: 400 encounters × 6 min
Hypothetical — substitute your own volume and timing
13 hrs
With review-ready recommendations: 400 × 2 min
Hypothetical — not a benchmark
~27 hrs
Hours freed per month — multiply by your loaded hourly rate
Hypothetical arithmetic only

Add whatever revenue leakage a review pass might catch (undercoded or rejected claims × your average allowed amount), then subtract the honest costs: per-encounter or subscription fees, the reviewer time that doesn’t go away, integration work, and the quarterly audit you should be running anyway. Recovered hours only turn into money if they get reallocated to work that collects — appeals, aged AR, patient balances — not absorbed into slack. Our claims and billing automation primer walks the adjacent workflow.

Questions worth asking any coding AI vendor in 2026

Which encounter types is it validated on, and can you see per-specialty performance rather than a blended number? What happens to low-confidence cases — silent submission, or a queue? Can you export every AI-assigned code with its supporting documentation for an audit? Is there a BAA, and does your data train their models? Can you turn autonomy off per provider or per code family while you build trust? And what does month-13 pricing look like, after the pilot discount?

Treat any accuracy figure as a marketing claim until you’ve reproduced it. Our opinion, stated as opinion: assume the number was computed on a dataset the vendor selected. Validate it concretely — hold back roughly 100 already-adjudicated charts spanning your top three encounter types, run the tool blind against them, and have your coding auditor score its output against the original coding and the payer’s actual adjudication before you sign. Disagreements are the useful part; read them one by one.

One heuristic, offered as opinion rather than measurement: if your monthly coding volume is small enough that one person handles it comfortably, buy assistance, not autonomy. The audit exposure of unreviewed claims scales faster than the savings do at small volume.

If your real bottleneck is denials, aging AR, or documentation quality rather than the coding step itself, fix that first. AI applied to a clean process compounds. AI applied to a broken one just produces wrong answers faster.

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