pitch.acords.co
The industry runs on standard forms. Your agent reads typed fields.
The loss notice that opens every claim, as one typed field model — free and keyless today; everything callable is roadmap, and says so. An independent reference, not affiliated with ACORD Corporation.
↓ scroll · arrow keys
The most-searched document names in insurance are form numbers: the certificate of insurance, and the property, auto, and liability loss notices. They are the industry-standard forms published by ACORD Corporation, the industry's standards body — carriers, agencies, and management systems license the paper through ACORD, and when a producer says "file the loss notice," they mean a specific, standardized set of data fields.
Wave 1 on this door is the loss notice: the first notice of loss (FNOL) a producer, broker, or insured files to open a claim. Its fields are the intake record of the entire claims loop — who reported, under which policy, what happened, where, when, and who to contact. Every statutory deadline and every adjuster assignment keys off this record, and the FNOL clock starts the moment it is filed — usually on a record that is still paper.
It is the fields, not the paper, that an agent-first system needs typed. The forms are standardized; the data has no standard machine shape. That gap is this door.
The door serves today: the reference page defines the document family in plain language, publishes the typed field model free and keyless, renders a specimen labeled fictional data in an original layout, runs the early-access capture, states its independence from ACORD Corporation, and says in its own fine print that there is no live parser or API behind the page yet.
This is the shape a filed loss notice resolves to, whichever standard form carried it — the reference an answer engine can quote and an agent can build against:
// components.schemas.LossNotice — served in /openapi.json today
{
"form": "property | auto | liability", // which loss-notice family the record maps to
"reported_at": "datetime", // when the notice was filed — FNOL clocks start here
"reported_by": "string", // who filed it: the insured, the producer of record, a broker
"carrier": "string", // carrier the notice is addressed to
"policy_number": "string", // policy the loss is claimed under
"term_start": "date", "term_end": "date", // policy period
"named_insured": "string",
"contact": "object", // name, phone, email — who the adjuster should reach
"date_of_loss": "date", "time_of_loss": "time", // when the loss happened, as precisely as known
"loss_type": "string", // peril: wind_hail, fire, water, collision, liability …
"loss_location": "string",
"description": "text", // plain-language account of the loss, injuries noted
"authorities_contacted": "string", // police or fire report, if any
"remarks": "text" // anything material that does not fit a field
}
The field model is served, not sketched: /openapi.json answers today as an OpenAPI 3.1 stub carrying components.schemas.LossNotice (with NoticeContact), and every operation in it is tagged x-status: roadmap — the spec itself says nothing is callable yet.
Standard-form processing is the classic insurtech document wedge, and this estate takes it on purpose, at the intake end, for stated reasons:
The typed surface being built over the field model, exactly as the door lists it:
| verb | what it does | status |
|---|---|---|
parse | a completed loss notice in, typed FNOL fields out — insured, policy, loss date, peril, location, description | roadmap |
prefill | draft a loss notice from an intake conversation, every required field present before it goes anywhere | roadmap |
validate | flag missing or inconsistent fields — a loss date outside the policy term — before submission | roadmap |
route | deliver the finished notice to the right carrier intake for the line of business | roadmap |
Nothing above is callable today. The spec is served; parse and the schema read are typed in it and tagged x-status: roadmap; prefill, validate, and route are filed ROADMAP on the door's /llms.txt and enter the spec as they are typed. This claim flips posted per operation, as each starts answering.
The MCP surface — parse_loss_notice, get_loss_notice_schema, prefill_loss_notice — is documented on the door before it exists, so nobody mistakes a plan for a product. It posts when the endpoint answers.
The trademark line. acords.co is an independent reference and is not affiliated with, endorsed by, or licensed by ACORD Corporation. ACORD and the form numbers are ACORD Corporation's marks, used nominatively to identify the industry-standard forms; the forms themselves are ACORD's copyrighted publications, and this door reproduces none of them — it types the data fields the documents commonly carry, and its specimen is an original illustrative layout with fictional values. That posture is not fine print bolted on for a deck: it is stated on the door's own surfaces, machine-readably.
The reserved line. Filling, checking, and delivering a notice is open intake work — no state reserves any verb on this door. The claim a loss notice OPENS is another matter: deciding it is a licensed adjuster's act, and that reserved act lives behind the reserved line at api.insure, where a claim waiting on a license is typed PENDING_ADJUSTER, never an untyped queue. Nothing on this door decides a claim, and nothing here pretends to.
Both lines are stated in the door's own machine-readable text: /llms.txt serves today, free and keyless, carrying the independence and nominative-use statement, the field model, and the honest status of every surface — including, in its own words, that there is no live parser or API behind this door yet.
The estate's substrate serves: api.insure answers today with the open-vs-reserved capability contract stated on the page — the reserved line typed PENDING_ADJUSTER — and says candidly that it is early access.
A field model can be published in the open; a document cannot be casually accepted. A real loss notice names an insured, their contact details, their property, their loss — so the callable surface is gated behind more than engineering, and the gates are stated rather than implied.
Custody before parsing: where a submitted document lives, who can read it, and retention ship with the first callable operation, and no document moves before they exist.
Pricing is unposted because it is unpriced: callable operations are designed to meter flat per document — never percent-of-indemnity, never contingent on the claim the notice opens; Indemnity is never a fee base anywhere in this estate — and the working fee posts here the moment real documents price it: ▮▮▮posts when first live fee data resolves. The free-tier promise is already posted: the reference, the field model, /llms.txt, and /openapi.json stay free and keyless.
The door's own /llms.txt files it exactly that way. One insurance estate, entered at different grains: api.insure is the per-claim demand rail whose primary caller is an agent; gigs.claims recruits the licensed adjusters behind the reserved line; apis.claims is the batch surface being built for the team that arrives with a book. The artifact doors bracket the claims loop itself: acords.co types the document that opens it, lossruns.claims types the history it leaves behind, and eobs.claims types the health-register statement on a separate rail — same discipline, different register, never blurred.
The long game, stated as design intent rather than fact: a claim administered on the estate's rail is born typed — FNOL intake as a POST, not a fax — so the notice becomes a record instead of paperwork. The artifact door is the outside-in half of that loop: it types the industry's paper while the rail earns the right to open the claims.
The cell's supply door serves: gigs.claims answers today, recruiting licensed adjusters and stating on the page that it is onboarding founding adjusters ahead of a live match queue.
The sibling artifact door serves: lossruns.claims publishes the loss run — the carrier-issued claims history — as a typed schema under the same free-and-keyless discipline.
The health-register sibling serves: eobs.claims publishes the Explanation of Benefits as a typed schema, in a register this door names and never blurs into.
The motion is B2D, content-led: claims-intake builders, reached where they already evaluate — the field model, the semantics, the spec — because for this ICP the reference is the first meeting. The secondary reader is not human: the kit (/llms.txt, /openapi.json, allow-all robots, the planned MCP endpoint) exists so agents and answer engines can quote the door verbatim, and being the shape they quote is the distribution. The only conversion on the page is the early-access capture; there is no paid or scaled acquisition.
One ICP, one motion, chosen explicitly: the intake builder and the intake document. The per-claim caller belongs to api.insure, the book-holder to apis.claims, the renewal builder to lossruns.claims, the licensed adjuster to gigs.claims — this door cross-points rather than absorbs.
Pre-launch, stated as pre-launch. The reference layer is live and keyless; every callable verb is roadmap; the specimen on the door is fictional, original, and labeled; and the load-bearing gates — custody terms, the first callable operation — are worn openly on the slides above rather than buried in fine print.
Live today, keyless: the reference, the typed LossNotice field model, the labeled fictional specimen, /llms.txt, /openapi.json with every operation tagged roadmap, allow-all robots, the early-access capture, and the independence statement — with the door's own fine print naming what does not exist yet.
The document family is wider than wave 1: the door names the certificate of insurance as the coverage-proof sibling of the loss notice, and its field model is roadmap. It posts when the fields are published, under the same independence posture.
The door's operating home follows the estate: open intake work files with the estate's software side, never the licensed cell. Graduation is pending and tracked here rather than decided silently.
Founding team spans the estate's demand rails, the substrate, and the regulated edge; a third co-founder currently leads AI at a public insurtech and joins at close.
The door serves today — acords.co. The field model is free and keyless; early access is the one ask on the page.
If this was forwarded to you: acords.co is the independent reference for the data fields on the insurance industry's standard forms — starting with the loss notice every claim opens with — published as a free, keyless typed field model, with the callable surface built in the open and labeled roadmap until it is real. It is not affiliated with ACORD Corporation, and it says so on every surface. Every claim above carries its own state and evidence. If you build claims intake, read the field model and get early access. If you know who does: forward this.