Where a claim sits on day one
A first notice of loss lands in the queue. It is a fender bender, or it is a commercial property claim with three contractors and a public adjuster already attached, and from the intake form alone you cannot tell which. Right now, a triage adjuster opens it, reads the loss description, pulls up the policy, checks whether the claimant has filed before, decides whether it is a fast-track payout or a full investigation, and routes it to the right desk. That adjuster does this forty or fifty times a day. The judgment is not hard. The reading is what takes the time.
This is the work that agentic ai workflows get asked to take on in claims, and it is worth being precise about what that phrase means here, because "agentic" has become a word vendors use to mean "has more than one step." In claims triage it means something specific: a sequence of model calls, each with a defined job, each handing its output to the next, with a person positioned at the point where a wrong call costs the most. Below is what that sequence actually looks like, step by step, on a real claim.
Step one: classify the claim
The system reads the first notice of loss, the loss description, and whatever photos or documents came in with it. It is not reading for an answer yet. It is sorting: line of business, severity band, likely coverage type, whether anything in the description (an injury, a fatality, a fire, a disputed liability) should pull the claim out of automated handling altogether and straight to a senior adjuster.
This classification step is doing less than it sounds like it is doing, and that is deliberate. It is not deciding whether the claim is valid. It is deciding which queue the claim belongs in and how much scrutiny it should get downstream. A claim classified as high severity gets a different, more conservative path through every step that follows. Get this step wrong and the error does not stay contained, it compounds, which is why the model's classification carries a confidence level forward rather than a flat yes or no.
Step two: pull the policy terms that actually apply
Once the claim is classified, the system goes to the policy itself; not a summary, not a product description, the bound policy with its endorsements, exclusions and any state-specific riders. It pulls the coverage language that applies to this specific loss type and this specific claimant, and it has to get the right version: policies get amended, endorsements get added mid-term, and a claim has to be checked against the terms in force on the date of loss, not the date it was filed.
This is where a retrieval step matters more than the model doing the reading. Retrieval, in plain terms, is how the system finds the right passage in the right document before it answers anything. Done well, it means the system is reading the actual clause that governs this claim. Done badly, or pointed at a generic policy library instead of the claimant's bound policy, it means the system answers from the wrong document with complete confidence, and nothing downstream catches it unless a person checks the citation. This is the single most common failure mode in claims-adjacent AI work, and it is a reason no claim should process on an answer without a traceable link back to the source clause.
Step three: check prior claims and flag what needs a look
The system then checks the claimant's claims history, inside the carrier and, where the data-sharing agreement allows it, against industry claims databases. It is looking for patterns: multiple claims in a short window, a prior denied claim on similar grounds, an address or vehicle that appears across more than one open file. This step does not accuse anyone of fraud. It surfaces a pattern and attaches it to the file as a flag for a human to weigh, because pattern matching is good at finding correlation and bad at explaining it.
It is worth being clear about what this step is not. It is not a fraud model running a score in the background that nobody can see. The flag, the reason for it, and the specific prior claims it is based on go into the file as something a special investigations reviewer can open and check, the same way an adjuster would if they had the time to pull the history themselves.
Step four: assign a route
With classification, policy terms and history in hand, the system proposes a route: straight-through payout under a defined dollar threshold, standard adjuster review, or escalation to special investigations or a senior adjuster. This is the step that looks, from the outside, like a decision. It is closer to a recommendation with its reasoning attached. The adjuster who picks up the file sees not just "route to SIU" but why: the specific prior claim, the specific clause, the specific inconsistency between the loss description and the policy terms.
That reasoning trail is the part worth insisting on before any of this goes live. A route with no visible reasoning is a black box an adjuster either rubber stamps or ignores, and an auditor later asking why a claim was fast tracked gets no answer except "the system said so."
What the adjuster actually sees
None of this should feel, to the adjuster, like a new interface to learn. It should feel like the file arrived further along than it used to: the loss type already tagged, the governing clause already pulled and cited, the prior claims history already checked, a recommended route already attached with its reasoning. The adjuster's job narrows to the part that needed a person anyway: does this reasoning hold up, is there context the system could not have had, does this claim get the route it was assigned or does it need to move.
For claims below an agreed dollar threshold with no flags raised anywhere in the sequence, a carrier may choose to let the route execute without a per-claim sign-off, provided the thresholds are set deliberately and reviewed on a schedule, not left to drift. Every claim above that threshold, every claim with a severity, fraud or policy-ambiguity flag, and every claim the system itself scores at low confidence, goes to a person before it moves. That boundary is not a technical setting. It is a decision about how much the business is willing to lose on the claims the system gets wrong, and that decision sits with the claims leader, not with whoever configured the model.
What it takes before any of this runs
None of the four steps work without three things in place first, and skipping any of them is where these projects quietly fail. The policy library has to be structured and current, with endorsements and amendments attached to the right claim date, not sitting in a shared drive as scanned PDFs with no version control. The claims history data has to be reachable, inside the claims management system and across whatever external databases the carrier uses, with the access and audit logging a regulator will ask about later. And there has to be an evaluation set: a sample of real, already-adjudicated claims the system is tested against before it ever sees a live one, so the firm knows its actual error rate on its own claims rather than trusting a vendor's benchmark on someone else's.
That third point is easy to skip and expensive to skip. A system that tests well on a vendor's demo data and has never been checked against this carrier's own loss types, its own policy language, its own historical claims, is a system nobody has actually measured.
Where the model gets it wrong
It will get claims wrong. A loss description written in unusual terms gets misclassified. A policy endorsement that modifies standard language gets missed because it was filed separately from the base policy. A prior claims match turns out to be a different person with a similar name. None of this is a reason not to build it. It is a reason to build the parts that catch it: confidence scoring that routes uncertain classifications to a person rather than guessing, citations on every policy reference so a reviewer can check the source in seconds rather than re-researching it, and a record of every override, because the claims an adjuster corrects are the clearest signal of where the system needs retraining or where a data source is stale.
A sequence like this is also where a carrier's own AI and claims teams, if it has them, tend to want to stay close to the build rather than hand it off whole. That is a reasonable instinct: the people who understand claims leakage, SIU thresholds and the state-by-state regulatory variation on claims handling are the people who should be setting the routing logic, even if someone else is writing the integration between the policy system and the model. Deciding which sits inside AI implementation as a discipline, not a one-off claims project, is worth a separate look at how AI implementation work gets structured end to end. For the data and permissions questions that sit underneath a system like this, the pattern is close to what carriers already face in connecting an AI review system to core operational platforms.
Where we come in
Alppoint builds systems like this end to end, inside the claims platform and policy systems a carrier already runs, or alongside an existing AI or data team that owns part of the build already. The work ships into the carrier's own environment, with the model, the routing logic and the evaluation set staying theirs to run and change after we are gone. If you are looking at where a claims workflow like this should start, that is a conversation worth having before the build, not after.



