Claims intake and triage, coverage review, underwriting assessment, fraud signals and policy document checks, run as agent teams on the Swarms API with adjusters deciding.
gpt-5.4-mini
peril covered under the form, estimate in range
claude-sonnet-5-5
reading the claim file
gemini-2.5-flash
reading the claim file
Use cases
Each card names the Swarms API swarm type it maps to and the agents you would send in the request. In every one of them the agents read, extract, score and draft; an adjuster, underwriter or investigator makes the decision.
Coverage, damage and fraud reviewer agents read the same claim file independently and each return approve, investigate or deny with a reason. The majority recommendation and every dissent go to the adjuster, who makes the decision.
A first notice of loss arrives as a call transcript, a web form or an email. Agents extract the policy number, loss date, peril and parties, pull the matching fields from attached documents and write the triage note in the claims system's format.
Property, loss history and location agents each score one part of a submission against the underwriting guide, and an aggregator writes the referral memo with the factors that drove the score. The underwriter accepts, refers or declines.
Pattern, network and narrative agents screen a claim at the same time: repeat claimants and providers, links between parties across the book, and inconsistencies between the statement and the documents. Flags go to the SIU queue with the evidence listed.
A director agent reviews a closed claim for recovery potential, assigns liability and evidence sub-tasks to worker agents, and assembles the demand package for the recovery team to review and send.
A router reads each coverage question from an agent or call center desk and sends it to the specialist for that line, which answers from the policy form and endorsements on file and quotes the clause it relied on.
Architecture
Three reviewer agents read the same claim file at the same time without seeing each other's answers. A tally agent counts the votes and returns the majority with each dissent attached. Watch a claim move through the desk.
Each reviewer gets the full claim file and its own system prompt: coverage checks the form and exclusions, damage checks the estimate, fraud checks history and timing. None of them sees the others' votes.
Routine form logic runs on a fast, cheap model. The estimate review, which needs more reasoning, runs on a stronger one. Mixing providers also means one model's blind spot is not everyone's.
The tally returns the winning vote and the count. A 3 of 3 approve on a glass claim can be fast-tracked by policy; a 2 to 1 split goes to the adjuster with the dissenting reason on top.
What comes back
A MajorityVoting response is a record, not a verdict. The left card is what one claim's response looks like once it is laid out in a claims system. The right panel is the underwriting counterpart: a submission scored factor by factor before an underwriter decides.
Coverage Reviewer
gpt-5.4-mini
APPROVESudden and accidental discharge is covered under HO-3 Coverage A. Gradual seepage exclusion does not apply on the facts given. $1,000 deductible.
Damage Reviewer
claude-sonnet-5-5
APPROVEEstimate of $14,850 for flooring, lower cabinets and drywall is consistent with the room described and 11 photos. Field visit not required.
Fraud Reviewer
gemini-2.5-flash
INVESTIGATEPlumber invoice is dated one day after the loss, which is plausible, but this is the third claim at the address in 24 months. Recommend an SIU desk review before payment.
tally APPROVE 2, INVESTIGATE 1, DENY 0
majority APPROVE, with the fraud dissent attached
adjuster decision pending, recorded in the claims system with the adjuster's name
Aggregator: waiting on 3 factor reports before writing the memo.
Code
The Swarms API examples share one request shape: a name, a swarm_type, a task and a list of agents. Set SWARMS_API_KEY from your Swarms Cloud account before running. None of these examples pays, reserves or denies anything.
import os
from swarms_client import SwarmsClient
client = SwarmsClient(api_key=os.environ["SWARMS_API_KEY"])
# Three reviewers read the same claim file independently. MajorityVoting
# returns the majority recommendation and keeps each vote, so a dissent from
# one reviewer is visible to the adjuster instead of averaged away.
CLAIM_FILE = """
Claim HO-2026-118342. Homeowners policy, Form HO-3, deductible $1,000.
Loss date 2026-10-28. Peril reported: water damage from a burst supply
line under the kitchen sink. Claimant estimate $14,850 (flooring, lower
cabinets, drywall). Plumber invoice attached dated 2026-10-29. Photos: 11.
Prior claims at this address: 2024 (wind, paid $6,200), 2025 (theft, denied).
"""
response = client.swarms.run(
name="Claim Decision Vote",
description="Independent coverage, damage and fraud reviews with a majority tally.",
swarm_type="MajorityVoting",
task=(
"Review the claim file below and answer with exactly one of APPROVE, "
"INVESTIGATE or DENY on the first line, followed by your reasoning and "
"the policy language or evidence you relied on.\n\n" + CLAIM_FILE
),
agents=[
{
"agent_name": "Coverage Reviewer",
"description": "Is the loss covered under the form and endorsements?",
"system_prompt": (
"You are a homeowners claims examiner. Decide whether the reported "
"peril is covered under an HO-3 form, name any exclusion that could "
"apply (gradual seepage, maintenance, flood) and state the deductible."
),
"model_name": "gpt-5.4-mini", # fast, the form logic is routine
"max_loops": 1,
},
{
"agent_name": "Damage Reviewer",
"description": "Is the estimate consistent with the damage described?",
"system_prompt": (
"You are a property damage appraiser. Compare the estimate to the "
"rooms, materials and photo count described, and say whether the "
"amount is in a plausible range for this loss type or needs a field visit."
),
"model_name": "claude-sonnet-5-5", # stronger reasoning over the estimate
"max_loops": 1,
},
{
"agent_name": "Fraud Reviewer",
"description": "Any indicators that warrant SIU referral?",
"system_prompt": (
"You are a special investigations analyst. Look for timing, prior "
"claim history, document inconsistencies and invoice dates that do "
"not fit the story. Recommend INVESTIGATE only with a concrete reason."
),
"model_name": "gemini-2.5-flash",
"max_loops": 1,
},
],
max_loops=1,
)
# The majority recommendation, the individual votes and the usage block.
# The adjuster reads this in the claims system; nothing is paid from here.
print(response)# One claim, three independent reviewers, a majority tally.
# The response is a recommendation for the adjuster; nothing is paid from here.
# Requires: SWARMS_API_KEY from Swarms Cloud, jq for the summary at the end.
# Replace the claim text with a redacted file exported from your claims system;
# the run is stored in Swarms Cloud under the name below.
curl -s -X POST https://api.swarms.world/v1/swarm/completions \
-H "x-api-key: $SWARMS_API_KEY" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{
"name": "Claim Decision Vote",
"description": "Independent coverage, damage and fraud reviews with a majority tally.",
"swarm_type": "MajorityVoting",
"task": "Review claim HO-2026-118342: HO-3 homeowners policy, $1,000 deductible, water damage from a burst supply line reported 2026-10-28, estimate $14,850 for flooring, lower cabinets and drywall, plumber invoice dated 2026-10-29, 11 photos, prior claims at the address in 2024 (wind, paid) and 2025 (theft, denied). Answer APPROVE, INVESTIGATE or DENY on the first line, then your reasoning.",
"agents": [
{
"agent_name": "Coverage Reviewer",
"description": "Is the loss covered under the form and endorsements?",
"system_prompt": "You are a homeowners claims examiner. Decide whether the peril is covered under an HO-3 form, name any exclusion that could apply and state the deductible.",
"model_name": "gpt-5.4-mini",
"max_loops": 1
},
{
"agent_name": "Damage Reviewer",
"description": "Is the estimate consistent with the damage described?",
"system_prompt": "You are a property damage appraiser. Say whether the estimate is in a plausible range for the loss described or needs a field visit.",
"model_name": "claude-sonnet-5-5",
"max_loops": 1
},
{
"agent_name": "Fraud Reviewer",
"description": "Any indicators that warrant SIU referral?",
"system_prompt": "You are a special investigations analyst. Look for timing, history, document and invoice inconsistencies. Recommend INVESTIGATE only with a concrete reason.",
"model_name": "gemini-2.5-flash",
"max_loops": 1
}
],
"rules": "Each reviewer answers independently and never refers to another reviewer.",
"max_loops": 1
}' | jq '{recommendation: .output, usage: .usage}'// Underwriting review as a MixtureOfAgents swarm: three specialists score
// their part of a submission in parallel and an aggregator writes the memo.
// The underwriter reads the memo and makes the accept, refer or decline call.
const SWARMS_API = "https://api.swarms.world/v1/swarm/completions"
type Submission = {
applicant: string
propertyType: string
yearBuilt: number
constructionClass: string
zip: string
priorLosses: { year: number; peril: string; paidUsd: number }[]
requestedLimitUsd: number
}
const specialist = (name: string, model: string, focus: string) => ({
agent_name: name,
system_prompt:
"You are a commercial property underwriting analyst. " +
focus +
" Score your area from 1 (favorable) to 5 (adverse), list the facts behind the score and name any guideline that requires referral.",
model_name: model,
max_loops: 1,
})
export async function reviewSubmission(s: Submission) {
const losses = s.priorLosses.map((l) => `${l.year} ${l.peril} $${l.paidUsd.toLocaleString()}`).join("; ") || "none"
const res = await fetch(SWARMS_API, {
method: "POST",
headers: {
"x-api-key": process.env.SWARMS_API_KEY!,
"Content-Type": "application/json",
},
body: JSON.stringify({
name: "Underwriting Submission Review",
swarm_type: "MixtureOfAgents",
task:
`Submission from ${s.applicant}: ${s.propertyType}, built ${s.yearBuilt}, ` +
`construction class ${s.constructionClass}, ZIP ${s.zip}, requested limit $${s.requestedLimitUsd.toLocaleString()}. ` +
`Prior losses: ${losses}. Produce a referral memo with a composite score and the factors that drove it.`,
agents: [
specialist("Property Agent", "gpt-5.4-mini", "Assess age, construction class, roof and systems for the property type."),
specialist("Loss History Agent", "claude-haiku-5-5", "Assess frequency and severity of prior losses against the line's loss ratio targets."),
specialist("Location Agent", "gemini-2.5-flash", "Assess wind, wildfire, flood and crime exposure for the ZIP and the protection class."),
{
agent_name: "Underwriting Aggregator",
system_prompt:
"You are a senior underwriter. Combine the three scores into a composite from 1 to 5, write a one-page referral memo and end with the reasons a human underwriter must review before any quote is issued.",
model_name: "claude-sonnet-5-5", // the memo is the deliverable, so the strongest writer
max_loops: 1,
},
],
max_loops: 1,
}),
})
if (!res.ok) throw new Error(`Swarms API ${res.status}: ${await res.text()}`)
const data = await res.json()
return { memo: data.output as string, usage: data.usage }
}
reviewSubmission({
applicant: "Harbor Street Bakery LLC",
propertyType: "single-story retail with commercial kitchen",
yearBuilt: 1987,
constructionClass: "joisted masonry",
zip: "33139",
priorLosses: [{ year: 2024, peril: "kitchen fire", paidUsd: 42_000 }],
requestedLimitUsd: 1_200_000,
}).then((r) => console.log(r.memo))import json
import os
import requests
BASE = "https://api.swarms.world"
HEADERS = {"x-api-key": os.environ["SWARMS_API_KEY"], "Content-Type": "application/json"}
# Overnight FNOL triage: every first notice of loss that arrived since the last
# run is turned into one swarm request, and the whole list is sent as a batch.
# The adjuster desk opens the triage notes in the morning; nothing is paid or
# denied by this job.
fnols = [
{"id": "AU-2026-220114", "text": "Rear-ended at a stoplight on I-95, other driver cited. Bumper and trunk damage, no injuries reported. Police report number attached."},
{"id": "HO-2026-118351", "text": "Tree fell on detached garage during the storm on 11/04. Roof partially collapsed, vehicle inside damaged. Photos attached."},
{"id": "AU-2026-220117", "text": "Windshield cracked by road debris on the highway. No other damage. Glass shop quote attached."},
]
AGENTS = [
{
"agent_name": "Intake Reader",
"system_prompt": "You are a claims intake specialist. Extract policy line, loss date, peril, parties, injuries and attached documents as JSON fields.",
"model_name": "claude-haiku-5-5", # extraction only, cheapest fast model
"max_loops": 1,
},
{
"agent_name": "Document Extractor",
"system_prompt": "You read the documents named in the intake fields and extract amounts, dates and reference numbers. Say which fields are missing.",
"model_name": "gpt-5.4-mini",
"max_loops": 1,
},
{
"agent_name": "Triage Writer",
"system_prompt": "You write the triage note an adjuster reads first: severity, suggested handling track (fast track, standard, complex), open questions. Recommend; do not decide coverage.",
"model_name": "claude-sonnet-5-5",
"max_loops": 1,
},
]
batch = [
{
"name": f"FNOL Triage {f['id']}",
"swarm_type": "SequentialWorkflow",
"task": f"First notice of loss {f['id']}: {f['text']}",
"agents": AGENTS,
"max_loops": 1,
}
for f in fnols
]
res = requests.post(f"{BASE}/v1/swarm/batch/completions", headers=HEADERS, data=json.dumps(batch), timeout=600)
res.raise_for_status()
results = res.json()
for fnol, result in zip(fnols, results):
print("=" * 72)
print(fnol["id"])
print(result["output"])
print("usage:", result["usage"])
# Each run in the batch also appears in Swarms Cloud with its usage, so the
# cost of the overnight job can be reconciled against the claim ids above.The Python SDK (pip install swarms-client) sends one claim file to three reviewer agents as a MajorityVoting swarm. Each reviewer answers independently on a different model, the majority is tallied, and the response carries every vote so the adjuster can see the dissent before deciding.
Swarms Cloud
Runs from the API land in Swarms Cloud with their inputs, each reviewer's output, token usage and cost. Name each run after the claim id and the full agent record for one claim is one query away when a complaint or an audit asks for it.
Runs / min
50
▲ last 30s
p50 latency
2.3s
▼ last 30s
Tokens / min
328.2k
▲ last 30s
Spend / hour
$11.41
▲ last 30s
Every run on the Swarms API appears in Swarms Cloud with its logs, token usage, cost and context use.
Open Swarms CloudThe request text, each agent's system prompt and output, the model ids, token counts and latency for the run, and the adjuster decision your own system recorded afterwards. The swarm logs endpoint returns the first five; the sixth stays with you.
Adjusters decide claims, underwriters decide risks and SIU decides referrals. The agents on this page produce recommendations with reasons attached, and any authority limit you have today still applies to the person who acts on them.
What claims leaders, underwriting managers and platform engineers ask before they put agents on a desk.
A single model reading a claim gives one opinion with no sense of how confident to be. Three reviewers on three different models answering independently show agreement or disagreement explicitly: a unanimous approve on a glass claim can go to a fast track, while a 2 to 1 split with a fraud dissent tells the adjuster exactly what to look at. The vote is a recommendation; the adjuster records the decision.
Swarm types on the Swarms APINo. The swarm returns a recommendation, the individual votes and the reasoning. Payment, reserve changes and denials stay in your claims system under your existing authority limits. If you want agents to take an action, you give them a tool with its own limits, and that is a separate design decision from the review itself.
Every run is stored in Swarms Cloud with the request, each agent's output, the models used, token counts and latency, and the same record is available over the API from the swarm logs endpoint. Naming each run after the claim id, as the examples do, lets you pull the full agent record for one claim in one query.
Each agent in the request carries its own model_name, so you choose per agent which provider sees what. A common split is a redaction or extraction agent on one model producing structured fields, and the reviewers working from those fields rather than the raw documents. Enterprise accounts can also discuss data handling and deployment options with the Swarms team.
Talk to salesCost is the token usage of each agent at its model's price, and the usage block comes back with every response. Cheap fast models (gpt-5.4-mini, claude-haiku-5-5, gemini-2.5-flash) handle extraction and routine checks, and a stronger model is used only where the writing or reasoning matters. The Swarms Cloud telemetry on this page shows the kind of per-swarm spend view you get.
Model pricingCreate a Swarms Cloud account, copy the claim vote example above, and paste in a redacted claim file. The run shows up in your logs with every vote and its cost.
New Swarms Cloud accounts start with $5 in API credits. Enterprise teams can talk to us about volume pricing, data handling and deployment options.