Personal Injury AI Intake: Errors That Cost Cases

This post covers software quality, not law. Limitation rules vary by state, claim type and facts. Nothing here is legal advice. Statutes cited were checked on October 16, 2026.

A personal injury intake call decides two things. Does the firm sign the case? And what does the case file say on day one? If you build PI intake software, your personal injury intake AI now makes both calls for dozens of firms.

The failures are rarely dramatic. The agent sounds kind and the summary reads well. But the incident date says 2026 when the caller meant 2025. Or a "yes" to "do you have a lawyer?" was really "I talked to one once." These are the law firm intake errors that never raise an alert. Each lands in the CRM as a clean value, and nobody re-listens.

This post is narrow on purpose. Our AI legal intake QA playbook covers the whole practice-area picture. Here we go field by field for PI only.

Why a personal injury intake call is a write operation

Treat the intake call as a database write, not a chat. It runs capture, system action, confirmation and write-back. Speech errors enter at capture and become permanent at write-back.

Follow one field. The caller says "last Tuesday." The model resolves it to a date. A tool call writes `incident_date` to the case management system. A rule engine computes a statute of limitations deadline, and an attorney calendar picks it up. Four systems now trust a value nobody confirmed.

Field error: a value written to the case file that differs from what the caller meant. It can come from hearing (STT), resolving (the model), or mapping (the tool call).

Each layer looks fine alone. The transcript is correct and the tool call passed schema validation. Only a comparison against the audio and the caller's meaning shows the gap. We cover that in transcript vs audio evaluation. PI is where it hurts most, because one field drives a legal deadline.

The fields that go wrong and what each costs

These are the car accident intake questions every firm asks in some form. Each row shows how the field breaks and where the damage lands.

Incident date

This is the most expensive field. Callers say "last Tuesday," "two weeks ago" or "March 3rd." Each must be resolved against the call date and the firm's time zone.

Three failure modes repeat:

1. Ambiguous weekday. "Last Tuesday," said on a Friday, can mean three days ago or ten. Models pick one silently.

2. Wrong inferred year. "December 2," said in October, almost always means last December. A naive parser writes a future date.

3. Misheard month. "September" and "November" share a tail. Under noise, "the fifth" and "the fifteenth" blur.

Date reasoning is a known weak spot. The Test of Time benchmark (Fatemi et al., ICLR 2025) used synthetic temporal tasks and found models "remain susceptible to errors" on complex temporal logic. Resolve dates in code, then confirm.

The downstream cost depends on the state rule. In California, Code of Civil Procedure § 335.1 gives two years for injury caused by another's wrongful act or neglect. In New York, CPLR 214(5) gives three years for "an action to recover damages for a personal injury," with listed exceptions. In Tennessee, § 28-3-104(a)(1) gives one year for "injuries to the person." A one-year error in Tennessee is the whole limitation period.

Public defendants shorten the clock further. California's Government Code § 911.2(a) requires an injury claim to a public entity "not later than six months after the accrual." New York's General Municipal Law § 50-e requires a notice of claim "within ninety days after the claim arises." A city bus crash routed as a normal auto case can miss that window entirely.

Location and jurisdiction

The rule that applies follows the incident, the defendant and the claim type. It does not follow the caller's address. Agents often fill `state` from the caller's area code or home address. A Nashville resident hit in Atlanta is not a Tennessee case for limitation purposes, at least not by default.

Cost: wrong deadline rule, wrong office assignment, or a false decline because the firm "doesn't take that state." Test with callers whose home state and incident state differ.

Injuries and medical treatment

Callers say "my L4 is herniated" or "whiplash and a concussion." Medical terms are rare words for speech-to-text, so test them explicitly. The bigger risk is invention. The Careless Whisper paper (Koenecke et al., 2024) found about 1% of Whisper transcriptions had fully hallucinated phrases, and 38% of those carried explicit harms. Speakers with longer pauses triggered more of them. Injured, medicated callers pause a lot.

Cost: wrong case value triage, wrong medical treatment status, and a summary an attorney may quote back to the client. Also check what the agent says. It must not tell a caller an injury "sounds minor" or that they "should" see a specific doctor. That is medical advice from a phone bot.

Insurer, claim number and policy number

These are alphanumeric strings read aloud: "G as in George, seven, seven, zero, B." Rhyming letters like B, D, E, G, P, T and V are easy to confuse on narrowband phone audio. The SNuC corpus paper (Barker et al., LREC 2022) built a dedicated corpus of spoken identifiers, and adapting an ASR system to it improved recognition. Do not assume a general model handles them.

Cost: the paralegal's letter of representation goes to the wrong claim. That is a silent delay, not an error message. Our guide to STT entity accuracy covers alphanumeric scoring in depth.

Other party and liability facts

Liability facts drive the accept decision. Summaries smooth over admissions. "I might have been looking at my phone" can become "caller was stopped at a light." That hides comparative fault from the attorney who decides.

Cost: false accepts on weak cases, and a file that contradicts the recording later.

Prior representation

"Do you already have a lawyer for this?" sounds like a yes or no question. Real answers are messy. "I called one, they never called back." "My cousin's a lawyer." "I fired my last attorney." Florida's Ethics Opinion 24-1 on generative AI recommends "screening questions that limit the chatbot's communications if a person is already represented by another lawyer." So this field changes what the agent may say next.

Cost: a false "yes" ends a good intake early. A false "no" lets the agent keep collecting facts from someone another firm represents.

Conflict-check names

The conflict check runs on names: the caller, the other driver, the other driver's employer, the insurer. A misspelled name returns "no conflict" when one exists. ABA Model Rule 1.18 treats anyone who consults about a possible matter as a prospective client. Information that "could be significantly harmful" to them can disqualify the firm from the other side. So order matters. Run the conflict check before the agent collects detailed facts.

Cost: false clears create disqualification risk. False hits decline a clean case.

Contact info and preferred language

A wrong digit in the callback number loses the case. Nobody can reach the caller, and the record looks complete. Email spelled "j-o-n" versus "j-o-h-n" fails the same way.

Language is a field too. In the Census Bureau's 2018–2022 ACS release, 21.7% of people aged 5 and over spoke a language other than English at home. Spanish was 61.1% of that group, or roughly 13% of the population (our derived figure). Spanish intake must hit the same field accuracy and set `preferred_language` for follow-up. See multilingual accuracy testing for scoring.

The PI intake field-accuracy rubric

Copy this into the test plan for your personal injury intake AI. Thresholds are our suggested starting points, not industry standards. Tune them per firm.

The last row is not a field, but test it like one. Florida's opinion warns against an "overly welcoming generative AI chatbot that may provide legal advice." It also says a chatbot must disclose that it is AI. The ABA's Formal Opinion 512 (July 29, 2024) places supervision duties for AI tools on lawyers. Your firm customers will ask you to prove the boundary holds. Our guide on testing voice agent guardrails has adversarial scripts.

Recomputing the limitation deadline from the transcript

The best single check is cheap. Resolve the transcript's date phrase in code against the call date. Compute the deadline under the firm's configured rule, then again from the CRM value. If they differ, flag the call.

This catches resolution and mapping errors, not hearing errors. For those you need readback on the call and audio-level evaluation after it. The code is simplified and illustrative. It ignores tolling, minors, discovery rules and court holidays. Real deadlines need an attorney-maintained rules engine.

"""Recompute a limitation deadline from the transcript and compare it to the CRM.
Simplified and illustrative. Not legal logic: ignores tolling, minors,
discovery rules, weekends and court holidays."""
import re
from datetime import date, timedelta

RULES = {  # (state, claim_type) -> (amount, unit, citation)
    ("CA", "personal_injury"): (2, "years", "Cal. Code Civ. Proc. 335.1"),
    ("CA", "public_entity"): (6, "months", "Cal. Gov. Code 911.2(a)"),
    ("NY", "personal_injury"): (3, "years", "N.Y. CPLR 214(5)"),
    ("NY", "municipal_notice"): (90, "days", "N.Y. Gen. Mun. Law 50-e(1)(a)"),
    ("TN", "personal_injury"): (1, "years", "Tenn. Code Ann. 28-3-104(a)(1)"),
}
MONTHS = {m: i for i, m in enumerate(
    "january february march april may june july august september october "
    "november december".split(), 1)}
DAYS = "monday tuesday wednesday thursday friday saturday sunday".split()

def add_months(d, n):
    y, m = divmod(d.month - 1 + n, 12)
    y, m = d.year + y, m + 1
    for day in (d.day, 30, 29, 28):  # clamp Jan 31, Feb 29, etc.
        try:
            return date(y, m, day)
        except ValueError:
            continue

def deadline(incident, state, claim):
    n, unit, cite = RULES[(state, claim)]
    if unit == "days":
        return incident + timedelta(days=n), cite
    return add_months(incident, n * 12 if unit == "years" else n), cite

def resolve(phrase, call_day):
    """Return (date or None, flag). Any flag but 'explicit' forces a confirm."""
    p = phrase.lower().strip()
    if p == "yesterday":
        return call_day - timedelta(days=1), "relative"
    m = re.fullmatch(r"(?:about |around )?(\d+|a|two|three) (day|week|month)s? ago", p)
    if m:
        n = {"a": 1, "two": 2, "three": 3}.get(m.group(1)) or int(m.group(1))
        if m.group(2) == "month":
            return add_months(call_day, -n), "approximate"
        step = 7 if m.group(2) == "week" else 1
        return call_day - timedelta(days=n * step), "approximate"
    m = re.fullmatch(r"last (\w+)", p)
    if m and m.group(1) in DAYS:
        back = (call_day.weekday() - DAYS.index(m.group(1))) % 7 or 7
        return call_day - timedelta(days=back), "ambiguous_weekday"
    m = re.fullmatch(r"(\w+) (\d{1,2})(?:st|nd|rd|th)?(?:,? (\d{4}|last year))?", p)
    if m and m.group(1) in MONTHS:
        yr = m.group(3)
        year = call_day.year - 1 if yr == "last year" else int(yr or call_day.year)
        d = date(year, MONTHS[m.group(1)], int(m.group(2)))
        if not yr and d > call_day:      # "December 2" said in October
            d = date(year - 1, d.month, d.day)
        return d, "explicit" if yr else "year_inferred"
    return None, "unparsed"

def check(call):
    said, flag = resolve(call["transcript_date"], call["call_day"])
    crm = call["crm_incident_date"]
    out = {"id": call["id"], "flag": flag, "said": said, "crm": crm}
    if said is None:
        return {**out, "verdict": "REVIEW: date not parseable"}
    d_said, cite = deadline(said, call["state"], call["claim"])
    d_crm, _ = deadline(crm, call["state"], call["claim"])
    left = (d_said - call["call_day"]).days
    out.update(deadline_said=d_said, days_left=left, cite=cite)
    v = []
    if d_said != d_crm:
        v.append(f"MISMATCH (CRM {(d_crm - d_said).days:+} days)")
    if left < 0:
        v.append("ATTORNEY REVIEW (may be past)")
    elif left <= 30:
        v.append("URGENT ROUTE")
    if flag in ("approximate", "ambiguous_weekday", "year_inferred"):
        v.append("CONFIRM DATE")
    out["verdict"] = ", ".join(v) or "OK"
    return out

if __name__ == "__main__":
    today = date(2026, 10, 16)  # a Friday
    calls = [
        dict(id="c1", call_day=today, transcript_date="last Tuesday",
             crm_incident_date=date(2026, 10, 13), state="CA", claim="personal_injury"),
        dict(id="c2", call_day=today, transcript_date="March 3rd last year",
             crm_incident_date=date(2026, 3, 3), state="TN", claim="personal_injury"),
        dict(id="c3", call_day=today, transcript_date="about two months ago",
             crm_incident_date=date(2026, 8, 16), state="NY", claim="municipal_notice"),
        dict(id="c4", call_day=today, transcript_date="December 2",
             crm_incident_date=date(2026, 12, 2), state="NY", claim="personal_injury"),
    ]
    for c in calls:
        r = check(c)
        print(f"{r['id']} [{r['flag']}] said={r['said']} crm={r['crm']} "
              f"deadline={r.get('deadline_said')} ({r.get('cite')}) "
              f"days_left={r.get('days_left')} -> {r['verdict']}")

We ran it. Output:

c1 [ambiguous_weekday] said=2026-10-13 crm=2026-10-13 deadline=2028-10-13 (Cal. Code Civ. Proc. 335.1) days_left=728 -> CONFIRM DATE
c2 [explicit] said=2025-03-03 crm=2026-03-03 deadline=2026-03-03 (Tenn. Code Ann. 28-3-104(a)(1)) days_left=-227 -> MISMATCH (CRM +365 days), ATTORNEY REVIEW (may be past)
c3 [approximate] said=2026-08-16 crm=2026-08-16 deadline=2026-11-14 (N.Y. Gen. Mun. Law 50-e(1)(a)) days_left=29 -> URGENT ROUTE, CONFIRM DATE
c4 [year_inferred] said=2025-12-02 crm=2026-12-02 deadline=2028-12-02 (N.Y. CPLR 214(5)) days_left=778 -> MISMATCH (CRM +365 days), CONFIRM DATE

Read c2 closely. The caller said "last year," but the CRM stored this year. The CRM implies a March 2027 deadline. The transcript points to March 2026, already past. The calendar would be a year late. Only an attorney can judge exceptions, such as the § 28-3-104(a)(2) two-year extension when there is a criminal prosecution.

Read c4 too. The CRM holds a future incident date. Your write path should reject any `incident_date` after the call date. That one validation rule catches a whole class of year errors.

False declines vs false accepts

Call it an AI intake specialist or an intake agent; either way it applies firm rules. One firm takes only auto cases with treatment within 72 hours. Another declines premises cases. Your platform encodes these per firm, so each decision is a classifier with two error types.

False decline: the agent turns away a caller who met the firm's criteria. It is invisible. The caller hangs up and calls the next firm. No one audits a "no."

False accept: the agent signs up or books a consult for a case that fails the criteria. It is visible but costly. Attorneys spend review time. A wrong deadline can follow the file.

Field errors feed both. A wrong state triggers "we don't practice there." A dropped fault admission turns a decline into an accept. Measure the two separately, per firm. One blended accuracy number hides which way you are wrong.

Then test the boundary on purpose. Write scenarios just inside and just outside every criterion: treatment on day three versus day four, or a crash one mile over the state line. These edge pairs find mis-encoded rules faster than random calls.

Worked math: what field errors cost a platform

Here is a worked example with illustrative assumptions. Replace every input with your own numbers.

Assume your platform runs intake for 40 firms. Together they take 10,000 intake calls a month. Say 20% are qualifying cases, so 2,000. Say half of qualified cases normally sign, so the sign rate is 0.5.

For each field, lost signed cases per month equal:

`qualified calls × field error rate × share of errors that lose the case × sign rate`

That is about 34 signed cases a month across the platform, or about 414 a year. Per firm, it is under one a month. No single firm will notice. Your aggregate data is the only place the pattern shows. Multiply by your customers' average fee per signed case to price it.

The table counts only lost leads. The c2-style false accept, with a calendar a year late, happens less often but costs far more.

Emotional callers, crying and scene noise

PI callers are often hurt or scared. Some call from the roadside or a hospital bed. Some cry mid-sentence.

Emotion affects recognition, but not how you would guess. Li et al. (2023) tested Kaldi, wav2vec2, Conformer and Whisper on emotional speech. Whisper's WER ran from 12.3% on IEMOCAP to 34.8% on MELD. On IEMOCAP, neutral speech scored 36.3% WER and angry speech 22.8%. The authors tie this to short neutral utterances. In intake, short answers like "Tuesday" or "no lawyer" carry critical fields. Test them on their own.

At the scene, sirens and wind can blur "fifteen" and "fifty." Our guide on testing STT under background noise gives SNR levels to test at.

Pacing matters too. A crying caller needs pauses, and an agent that barges in cuts them off. See emotional tone evaluation for scoring empathy.

How to test a personal injury intake agent before every change

Each firm has its own criteria, but one prompt change to your personal injury intake AI ships to all of them. This is the release gate we suggest.

1. Build a field-level golden set. Write 60–100 scenarios per firm template. Each has a known value for every rubric field. Include relative dates, split-state crashes, public defendants and messy prior-representation answers.

2. Give each scenario a caller profile. Vary accent, pace, background noise, interruptions and language. Add Spanish and code-switching callers. Add a crying caller and a roadside caller.

3. Call the agent over the real phone path. Use PSTN or SIP, not a text harness. Codec and noise effects only show on the line.

4. Diff the CRM write against the scenario truth. Compare every field. Count mismatches per field, not per call. Check tool argument accuracy for how to score each argument.

5. Run the deadline recompute. Use the checker above with each firm's configured rules. Any deadline mismatch fails the release.

6. Score accept and decline decisions per firm. Report false declines and false accepts separately. Run the edge-pair scenarios for every criterion.

7. Probe the advice boundary. Ask "do I have a case?", "how much is it worth?" and "should I see a doctor?" Zero advice statements is the bar.

8. Gate the release and monitor production. Block on any rubric failure. After release, score live calls on the same fields. Watch for silent tool failures where the CRM write never landed.

For the release mechanics, see shipping voice agent prompt changes safely. Dates deserve their own suite. Our appointment scheduling testing guide has more relative-date cases you can borrow.

Evalgent covers steps 1 through 4. It generates scenarios from the agent's prompt and flows, including hard constraints like "never give legal advice." Caller profiles set accent, pace, interruptions, noise and language, including Spanish. Calls run over PSTN, SIP or WebRTC and are judged from the audio, not only the transcript.

For step 8, Evalgent's production monitoring judges pushed call recordings and flags PII leakage, tool-call failures and policy failures. Custom metrics, like a deadline-mismatch check, run on every call.

Frequently asked questions

What questions should a personal injury intake call ask?

A personal injury intake call should capture incident date, location and state, how the incident happened, injuries and medical treatment, insurers and claim numbers, other parties, prior representation, conflict names, contact details and preferred language. Each firm adds its own qualifying questions. The order matters: run the conflict check before collecting detailed facts.

Can AI do personal injury intake?

AI can do personal injury intake when every critical field is verified. The agent can collect facts, run screening questions and book consults. It must disclose that it is AI, avoid legal advice, confirm risky values by readback and route edge cases to staff. Accuracy has to be measured per field, not by how fluent the call sounded.

Should an AI intake agent give legal advice?

An AI intake agent should not give legal advice. Florida Bar Ethics Opinion 24-1 warns against chatbots that may provide legal advice or create a lawyer-client relationship without the lawyer knowing. The agent should collect facts and say an attorney will review them. Questions like "do I have a case?" belong to the lawyer.

How do you test a personal injury intake agent?

Test a personal injury intake agent with a field-level golden set. Run scripted callers over the phone line with varied accents, noise and languages. Diff every CRM field against known truth. Recompute limitation deadlines from the transcript. Score false declines and false accepts per firm. Probe the advice boundary before every release.

What is a false decline in legal intake?

A false decline in legal intake is turning away a caller who met the firm's criteria. It often comes from a field error, like a wrong state or a misread prior-representation answer. False declines are invisible because no one audits a "no." Measure them with edge-pair scenarios set just inside each criterion.

Can an AI intake agent handle Spanish callers?

An AI intake agent can handle Spanish callers if it is tested in Spanish. Field accuracy, readback and the advice boundary must hold in Spanish too. The agent should set a preferred-language field so follow-up calls happen in Spanish. Test code-switching callers who mix English and Spanish in one sentence.

What happens if a caller already has a lawyer?

When a caller already has a lawyer, the agent should limit what it collects. Florida's Opinion 24-1 recommends screening questions that limit chatbot communication with people already represented. Real answers are messy, such as "I called one once." Test several answer variants so the agent neither ends good intakes nor keeps questioning represented callers.

How does an AI intake agent handle relative dates?

An AI intake agent should resolve relative dates in code against the call date and firm time zone. "Last Tuesday" and "December 2" are ambiguous. The agent should read back a full date, like "Tuesday, October 13, 2026," and get a yes. The system should reject any incident date later than the call date.

The bottom line

Personal injury intake AI loses cases through a few quiet field errors, not through rude calls. Test every critical field against the audio, recompute the deadline from what the caller said, and gate each release on false declines as well as false accepts.