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.
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
Minute 0
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
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
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
Validate and add rules
Set validation rules, required fields, and the assignment logic. This is where a day or two goes, not weeks.
- 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
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
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.
“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
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.
Related reading
Automating SAP data entry without a license or a five-figure quote
How accessibility-API agents reach desktop SAP work that the API-integrated automation wave cannot, with documented per-workflow numbers.
Accessibility tree vs pixels: the input layer that decides everything
Why pixel-matching RPA breaks when a theme changes, why accessibility-API agents do not, and what each surface gives up.
The legacy desktop apps with no API, and why that is the moat
The systems a SaaS connector can never reach are the ones where a desktop agent is the only thing that works.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.