A guide for carriers

Automated claims intake with fast setup. Here is what fast actually means, and why it is days and not months.

Most claims-automation tools quote a rollout in months because each field in the claim screen has to be mapped by hand, then re-mapped every time the screen changes. The fast-setup version skips the mapping entirely: a CSR records one real claim, and the agent learns the workflow from the recording. This page explains exactly how that works, what the setup steps are, and what the timeline looks like for a carrier.

M
Matthew Diakonov
8 min

Direct answer, verified 2026-06-20

Fast setup means days, not months. A single intake type is typically in production inside one week, and a multi-state, multi-product intake suite usually ships in two to three weeks. The timeline is short because setup is one screen recording of a CSR handling a single claim, not a per-field selector-mapping project. The agent then drives the same desktop claim screens through Windows accessibility APIs, the same interfaces a screen reader uses, so there is nothing to hand-map at setup and nothing to re-map when the claim system pushes a UI update.

Where the months usually go, and why setup here does not

Walk a CSR through a single first notice of loss on the floor of any mid-market carrier and the cost is obvious: open the desktop claim client, type fifteen to twenty fields, run the assignment rule, save, repeat. That is roughly thirty minutes per claim, and it is the part that does not get automated by the FNOL voice bots and OCR parsers most claims-automation pages describe. Those tools capture the claim; a human still types it into the system of record.

Automating that typing with traditional RPA is what takes months. A UiPath or Automation Anywhere bot is built against selectors or pixel regions tied to the exact layout of the claim form. Building those selectors is the slow part of the rollout. Re-building them every quarter when Guidewire ClaimCenter or Duck Creek Claims re-themes the form is the slow part of the maintenance. The setup time and the maintenance time are the same problem showing up twice.

The fast-setup approach removes the mapping step. The agent reads the claim screen through Windows accessibility APIs, the way a screen reader does, so it identifies a field by its accessible name rather than its pixel position. Nothing gets hand-mapped, which is the entire reason the clock reads days. For the broader claims workflow numbers, see the insurance claims intake solution.

The setup clock, from first recording to production

01 / 04

Minute 0

A CSR starts the recorder in the web app and opens the first claim in the desktop claim client.

The anchor: setup is a single screen recording

You can see the mechanism in the no-code web app at app.mediar.ai/web. When you start a recording, the screen shows a Screen Capture view, a Timeline Preview that stacks the captured screenshots in order, an Events tab that lists the discrete actions, and a Workflow tab that turns those events into a structured, editable workflow. That Workflow tab is the whole setup artifact. A CSR produces it by doing their job once. There is no separate authoring step where a developer writes field selectors, because the recorder already extracted the structure from the recording. This is the concrete reason the timeline is days rather than months, and it is the part a generic claims-automation page cannot copy, because it is a property of how the product reads the screen.

Setup, in four steps

  1. 1

    Record one claim

    A CSR opens the desktop claim client and walks one real FNOL end to end while the recorder watches. No script, no field map.

  2. 2

    Recorder emits the workflow

    The Workflow tab turns the captured screen events into a structured, editable workflow. You read it, you do not write it.

  3. 3

    Validate and add rules

    Set validation rules, required fields, and the assignment logic. This is where a day or two goes, not weeks.

  4. 4

    Run in production

    The agent drives the same screens through Windows accessibility APIs. First intake type live inside a week.

One recording becomes a workflow that drives the claim systems

The recorded workflow is the single source. From it, the agent drives whatever desktop claim systems the carrier already runs, because the accessibility layer is the same across all of them.

From one recording to the systems of record

Recorded claim
Validation rules
Assignment logic
Mediar agent
Guidewire ClaimCenter
Duck Creek Claims
Salesforce claim screens
Green-screen mainframe

What changes once the recording is live

One FNOL, by hand versus by agent

A CSR opens the desktop claim client, reads the FNOL, and types every field, then runs the assignment rule and saves.

  • About 30 minutes per claim
  • Capacity is a hiring decision
  • Backs up during catastrophe spikes

The documented numbers

0 minmanual claim intake, per claim
0 minwith the agent, per claim
$0K/yrsaved at one mid-market carrier
$0/minruntime billing, no per-seat

The per-claim figures are from a mid-market carrier that moved claims intake from 30 minutes to 2 minutes, which their team counted as $750K/year of recovered clerk time. Runtime is billed at $0.75 per minute with no per-seat licensing.

$750K/yr

Claims intake at one mid-market carrier went from 30 minutes per claim to 2 minutes. That is their team's headcount math, not a press-release number.

Mediar deployment, mid-market insurance carrier

Reaches the desktop claim systems carriers already run

Guidewire ClaimCenterDuck Creek ClaimsSalesforce claim screensAS/400 green-screenSapiensOrigami RiskCustom intake desktop apps

When the fast-setup desktop approach is the wrong fit

It is worth being honest about the cases where this is not the answer. If a carrier is fully cloud-native on a SaaS claim platform with a real REST API, the right shape is a direct integration against that API, not a desktop agent. The accessibility-API approach earns its place precisely where there is no API to integrate against: the desktop claim client on a CSR workstation, the green-screen terminal, the thick client that the SaaS connectors never shipped support for.

The other honest caveat is the intake portal itself. A web-only FNOL portal is browser work, and browser-based agents handle it well. The fast-setup story here is specifically about the part after intake: getting the captured claim typed into a desktop system of record without a months-long mapping project. If your bottleneck is the web form, this is not the tool you need. If your bottleneck is the desktop claim client, it is.

See your own claim screen recorded once and running

Book a working session: a CSR records one FNOL in your desktop claim client and we run the agent against it, so you can judge the days-not-months claim against your actual system.

Questions carriers ask before the pilot

How fast can automated claims intake actually be set up for a carrier?

Days, not months. The agent learns by watching a CSR walk through one real claim in the desktop claim client end to end. After that single recording, the recorder generates the structured workflow and the agent runs it. A single intake type is typically in production inside one week, and a multi-state, multi-product intake suite usually ships in two to three weeks. The reason it is days and not months is that there is no per-field selector mapping project. A UiPath ClaimCenter rollout is usually quoted in months because each field has to be mapped, and re-mapped any time the underlying screen changes.

What does setup involve, step by step?

Four steps. One, a CSR opens the desktop claim client and records themselves handling one real FNOL. Two, the Workflow tab in the web app turns the captured screen events into a structured workflow you can read and edit, rather than one you have to write. Three, an ops lead adds validation rules, required-field checks, and the assignment logic; this is where a day or two of the work goes. Four, the agent runs in production, driving the same screens through Windows accessibility APIs. There is no developer-certification course, no per-bot provisioning, and no integration license to buy from the claim-system vendor before you can start.

Why is this faster than UiPath or Automation Anywhere for the same claim screens?

Because of where the automation reads the screen. UiPath and Automation Anywhere bots are usually built against selectors or pixel matchers tied to the exact layout of the claim form. Building those selectors is the slow part of the rollout, and re-building them every time the form changes is the slow part of the maintenance. Mediar drives the claim client through Windows accessibility APIs, the same interfaces a screen reader uses, so it reads a field as 'edit field, label Claimant Name, value empty' rather than as a pixel region. There is nothing to hand-map at setup, which is what collapses the timeline from months to days.

Will it still work when our claim system pushes a UI update?

Yes, and that is the point of using the accessibility layer. Quarterly UI refreshes to Guidewire ClaimCenter or Duck Creek Claims move pixels and re-theme controls, which is what breaks pixel-based and selector-based RPA. The accessible name of a field, the thing a screen reader reads, usually survives a re-theme, so the agent keeps finding the right field. The self-healing layer recovers when a control's accessible name does change, instead of failing the run. The practical effect is that fast setup is not paid back later as fragile maintenance.

Does it work on the desktop claim client, or only a web intake portal?

The desktop claim client is exactly where it is built to work, and that is the gap most claims-automation tools leave open. Browser-based AI agents work against web-only intake portals, and they are good at that side. The 30 minutes per claim that cost real money is on the other side: opening the Guidewire ClaimCenter or Duck Creek Claims desktop client on a CSR workstation, typing every field, and clicking the assignment rule. That client is a Windows desktop app. Browser-only agents cannot reach it. If your data lives in a desktop claim center, the automation has to live there too.

What is the cost, and is there a per-seat or per-bot fee?

Mediar bills $0.75 per minute of agent runtime, with no per-seat licensing and no per-bot fee. There is a $10,000 turn-key program fee that converts to credits with a bonus, so it is effectively prepaid usage rather than a separate license. Because capacity is a runtime cost rather than a hiring or licensing cost, a claim-volume spike doubles the minute count you bill, but it does not require a new license, a new workstation image, or a new project from the RPA Center of Excellence.

Is it secure and compliant enough for a carrier's PII?

Mediar is SOC 2 Type II certified and HIPAA compliant, and the desktop agent can run on-prem or inside the carrier's existing Windows VDI rather than in our cloud. PII never leaves the carrier's network unless you choose the managed cloud option. Every run produces an audit log with the field values it typed and a screenshot of the resulting claim screen, which is what compliance and audit teams ask for on each carrier engagement.

Can our own team extend it, or are we locked to the vendor?

The primitive layer is open source. Mediar publishes the Terminator SDK at github.com/mediar-ai/terminator, an open-source library for driving Windows UI Automation from Rust, Python, or Node, and it is the same surface Mediar uses internally. Teams that want a custom workflow or their own agent against the same accessibility-API layer build on Terminator. The Mediar product on top adds the workflow recorder, the no-code web app at app.mediar.ai/web, the SOC 2 and HIPAA control plane, the audit logs, the validation rules, the self-healing layer, and the runtime billing.

How did this page land for you?

React to reveal totals

Comments ()

Leave a comment to see what others are saying.

Public and anonymous. No signup.