Pre-Issuance Verification (PIVC)

Pre-Issuance Verification (PIVC)

Run a standardized, recorded Pre-Issuance Verification Call (PIVC) on 100% of your policies — with a deterministic flow agent whose regulated script cannot be skipped, 100% AI QA on every call, and a consent + audit trail your compliance team can export.

Built on the Telenow App Platform as a pure declarative app: the data model, the agent tools, the Policy-Admin-System webhook, the verification workflow, the deterministic flow agent, and the regulated-script knowledge base all run on-platform. No external server.

The problem (and the number)

Mis-selling is the single largest source of life-insurance complaints in India. In FY25 the IRDAI Bima Bharosa / Integrated Grievance system logged 26,667 mis-selling grievances against life insurers — policies sold to people who did not understand the premium commitment, the tenure, or the exclusions they were signing up for. The Insurance Amendment Bill 2025 raises the stakes further, adding stiffer penalties and sharper conduct obligations for exactly this.

The regulator's own remedy is the Pre-Issuance Verification Call (PIVC): before a policy is issued, the insurer calls the proposer on a recorded line and confirms — in the customer's own language — that they understand the premium, the term, and the key exclusions, and that they genuinely consent. Done properly on 100% of policies, it is the strongest defence an insurer has when a grievance lands.

The catch: a human tele-caller under a daily target rushes or skips the awkward disclosures, and a free-form voice bot wanders off script. Either way the regulated step that matters didn't happen — and you can't prove it did.

The differentiator: the script is a flow graph, not a suggestion

Pre-Issuance Verification (PIVC)'s bundled agent is a deterministic multi-context flow agent. The mandated script is encoded as nodes wired by always edges, executed in a fixed order that the agent physically cannot skip or reorder:

   lookup ──► disclose ──► understand ──► consent ──► free-look ──► end
 (find the   (read premium,  (confirm the   (capture    (explain the
  policy)     tenure &        holder         explicit    free-look
              exclusions      understood     recorded    window)
              VERBATIM)       each one)      consent)

Because the regulated steps are nodes, not free-form LLM latitude, no policy is ever verified on an incomplete call. That is the whole point — and it is enforced by the platform's flow engine, not by hoping the model behaves.

How it works

Policy Admin System  ──(policy issued webhook)──►  verification object (status: pending)
        │                                                     │
        │                                        fires object.verification.created
        ▼                                                     ▼
  dedupe on policy #                             verify_new_policy workflow
                                                   ├─ delay ~2 min
                                                   └─ outbound-call  {{settings.pivc_agent_id}}
                                                         → dials {{trigger.data.phone}}
                                                         → passes policy_no, holder_name, script_version
                                                             │
                                                             ▼
                                        PIVC Verification Agent (deterministic flow, recorded)
                                        find_verification → disclose → confirm → CONSENT → free-look
                                        → record_consent · mark_verified | mark_failed | mark_review · flag_review

A second workflow (freelook_followup) places a reminder call inside the free-look window. And an on: call.analyzed rule automatically opens a review item whenever a completed call reads as negative sentiment — a fast mis-selling early-warning.

Everything the agent does on the call updates the same verification rows you see on the dashboard — and the dashboard's Call now button dials through the same agent and tools.

Agent tools (used mid-call — all declarative)

The bundled PIVC Verification Agent is a deterministic flow: a find_verification tool node (looks the policy up in this app's data) → static disclosure → conversation understanding check → extract consent capture → conversation free-look → end. STT/TTS default to Sarvam (anushka) so Tier-2/3 policyholders are verified in their own language.

Dashboard pages

• Pre-Issuance Verification (PIVC) (dashboard) — KPI tiles (PIVC coverage %, avg QA score, consent rate %, verified, failed/review), a status-mix bar, recent verifications, and QA-score bands. Also powers the platform dashboard_widget slot in a compact form.
• Verifications — the queue, each row showing a consent proof cell (recorded consent + script version + recording link) and per-row Call now to (re)run a verification. Banner reminds you every verified row is an exportable evidence pack.
• Review — open compliance exceptions (resolve / reopen) plus every failed & review-flagged verification.
• Setup — a configuration checklist, a one-click Create PIVC agent button, and the post-install wiring steps.

Knowledge base

pivc-script ships four real documents the flow agent reads from: the mandated PIVC script (read in order), consent language, free-look rules, and mis-selling red flags → open a review item.

Install & post-install wiring

1. Install Pre-Issuance Verification (PIVC) into your org.
2. Open Setup → Create PIVC agent (builds the bundled deterministic flow agent, auto-wired to the tools + KB).
3. Copy the new agent's ID into the app's PIVC agent ID setting (pivc_agent_id) so verify_new_policy can dial.
4. (Optional) Set Regulated script version (script_version, default v1) — bump it whenever compliance revises the mandated wording so the audit trail records exactly which script each holder heard.
5. Point your Policy-Admin-System policy issued webhook at the inbound hook — policy_issued (maps policy_number, proposer.name, proposer.phone, premium, tenure, exclusions, issued_at, deduped on policy #). The agent reads the premium, tenure and exclusions back verbatim on the call, so send the real values. Every newly issued policy now flows in and auto-dials.

Settings

Bulk verifying your backlog

The real-time path (webhook → workflow → call) covers newly issued policies. To sweep a backlog of already-issued-but-unverified policies, use the app-key campaign API:

POST /api/app-campaigns
{ "agentId": "<pivc agent id>",
  "targetQuery": { "status": "pending" },   // over the `verification` object
  "result": { ... write-back ... } }

Monetization

Pre-Issuance Verification (PIVC) is priced as a mandated compliance cost centre — per verification: a flat fee for each recorded pre-issuance verification the agent completes (verified or failed). Because a PIVC is regulatory-required on covered policies, the cost is a predictable per-policy line item — and dramatically cheaper than a single upheld mis-selling grievance, a refunded policy, or a conduct penalty under the Insurance Amendment Bill 2025. Failed catches and review flags are surfaced on the dashboard to make that ROI obvious.

Changelog

1.1.0 — 2026-07-12

• Renamed to Pre-Issuance Verification (PIVC) (business-friendly) with a marketplace icon.
• Added real UI screenshots (dashboard + key pages).
• Added premium/tenure/exclusions disclosure fields + hook mapping, mark_review, and free-look write-back.
• Verified end-to-end loop closure: trigger → workflow → call → agent tools → write-back → dashboard.

1.0.0

• Initial release.
• Data model: verification object (policy #, holder, phone, premium, tenure, exclusions, script version, consent, questions confirmed, free-look explained, QA score, recording URL, status, created_at) with pending / verified / failed-or-review saved views, plus a review_item object for compliance exceptions with an open view. Premium / tenure / exclusions are mapped in from the policy-issued webhook and passed to the call so the agent reads them back verbatim.
• Agent tools (declarative): find_verification, record_consent, mark_verified (also stamps free-look explained), mark_failed, mark_review (borderline → holds for human QA), flag_review.
• Bundled agent: PIVC Verification Agent — a deterministic multi-context flow (find_verification tool node → static premium/tenure/exclusion disclosure → confirm-understanding → extract explicit consent → free-look explanation → end, wired by always edges) so the regulated script cannot be skipped or reordered. Sarvam vernacular STT/TTS; recording enabled; auto-wired to the tools and the regulated-script knowledge base.
• Knowledge base: pivc-script — the mandated PIVC script (read in order), consent language, free-look rules, and mis-selling red flags.
• Automation: policy_issued inbound webhook (dedupe on policy #); verify_new_policy workflow (delay ~2 min → outbound verification call); freelook_followup workflow (delayed free-look reminder call); call.analyzed rule that opens a review item on negative-sentiment calls.
• Settings: pivc_agent_id (required) and script_version (default v1).
• Dashboard UI: KPI tiles (PIVC coverage %, avg QA score, consent rate %, verified, failed/review), verification status mix, recent verifications, and QA-score bands; also renders into the dashboard_widget slot in compact form.
• Verifications page: status filters, search, a consent-proof column (recorded consent + script version + recording link), an exportable-evidence banner, and per-verification Call now (passes policy context variables to the agent).
• Review page: open compliance exceptions (resolve / reopen) plus all failed & review-flagged verifications.
• Setup page: configuration checklist + one-click Create PIVC agent and post-install wiring steps.
• Self-seed: a fresh install auto-loads six realistic verifications across every status and one review item (removable) so the dashboard is populated on first open.