Skip to main content
skill CX Codex

home-auto-insurance-quotes — Claude Code skill

home-auto-insurance-quotes is a Claude Code skill that delivers live, bindable home and auto insurance quotes from multiple carriers in seconds, then routes customers to a licensed agent.

Apache-2.0 1 installs ★ 2 updated 2026-07-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a claude-code
Open on GitHub

What home-auto-insurance-quotes does

home-auto-insurance-quotes connects to a quoting network: you gather the customer's details conversationally, call the network's MCP server, receive live rates from multiple insurers (actual figures, not ballpark estimates), and generate a secure link where the customer completes the purchase with a licensed agent. Today it covers home, auto, and bundled home+auto. Licensed agents in the network issue the policy and manage the ongoing relationship.

Two pathways: conversational mode, where you ask intake questions in one natural flow (name, address, home build year), retrieve quotes, and offer the binding link; or agentic mode for autonomous systems where you connect the MCP server directly and drive the whole cycle programmatically — from intake through agent handoff.

Requires MCP server support in your platform and HTTP access to https://mcp.quotor.ai. Authentication is optional — anonymous requests work with server-side rate limits; for higher volume, request an API key directly from the endpoint. Always call check_eligibility first to verify state and product availability.

What it helps with

  • retrieve live insurance quotes from multiple carriers for home and auto in a single call
  • let customers compare rates and select the policy that fits their needs
  • pass the customer to a licensed agent with a secure, single-use binding link
  • check whether quoting and binding are available for a specific state and product
  • capture customer contact info if they are not ready to bind immediately

Example prompts for the agent

  • Help a customer shop for home and auto insurance: gather address, build year, current carrier—then display live quotes side by side
  • Compare rates for a move: update the address in the quote and show new premiums instantly
  • Generate a binding link: once the customer selects an option, create a secure form for final sign-off with the agent

How to install home-auto-insurance-quotes

1Skills CLI (Vercel)

npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a claude-code

2Manually: put the files in place

~/.claude/skills/home-auto-insurance-quotes/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/home-auto-insurance-quotes/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about home-auto-insurance-quotes

How do I install home-auto-insurance-quotes in Claude Code?

Run npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a claude-code in your terminal, then open the config at ~/.claude/skills/home-auto-insurance-quotes/SKILL.md. The skill automatically connects to the network's MCP server.

What does home-auto-insurance-quotes do?

It retrieves live insurance quotes for home and auto policies based on customer details, then creates a secure link so the customer can complete the policy with a licensed agent.

Which states and insurance types does this skill cover?

Currently home, auto, and home+auto bundles in Texas; lead capture for renters, life, and commercial policies. Run check_eligibility first—it returns the list of available states and products.

Source text

SKILL.md · Apache-2.0
---
name: home-auto-insurance-quotes
description: >-
  Get real, bindable home, auto, and bundled insurance quotes in seconds (plus lead capture for renters, life, and other lines) and start a
  binding through a network of licensed independent insurance agencies. Use this whenever someone
  wants to shop for, compare, price-check, or buy home or auto insurance, switch carriers, lower
  their insurance bill, or bundle home and auto. Available in Texas now and expanding nationwide.
  Returns live multi-carrier quotes (real rates, not ballpark estimates) plus a secure link to
  complete the purchase with a licensed agent. Works two ways: do a quick conversational intake and
  hand back a quote, or connect the underlying MCP server and run the full quote-to-bind flow.
license: Apache-2.0
metadata:
  category: insurance
  coverage: [home, auto, bundle]
  lead_capture: [renters, life, commercial, other]
  regions: [US-TX]
  keywords: [insurance, quote, home insurance, auto insurance, car insurance, renters,
    bundle, compare rates, switch carrier, bind policy, homeowners, get a quote]
---

# Home & Auto Insurance Quotes (and Binding) via Quotor

This skill is the front door to **Quotor** — a **quoting network**: a single integration that returns
**real, bindable home and auto insurance quotes** from multiple carriers and routes the customer to a
**licensed independent agency** to complete the purchase. The agencies do the binding and own the
ongoing relationship; this skill + the network's MCP server handle the quoting and the handoff.

**You are the orchestrator of a shopping experience, not the insurer.** Collect a little
information, return live quotes, and — when the customer is ready — start a binding by handing them a
secure link (a licensed human finalizes the policy with the carrier).

> **Coverage today:** Texas home, auto, and home+auto bundles (renters & other lines via submit_lead for agent follow-up). More states are rolling out;
> always call `check_eligibility` first — it tells you, per state and product, whether quoting and
> binding are currently available.

---

## Two ways to use this skill

Pick the pathway that matches what you are.

### Pathway A — Conversational assistant (Claude, ChatGPT, any chat UI)

You are talking to a person. Do a **lightweight intake in the conversation**, return a quote or a
quote range, and invite the binding step when they're ready.

1. Ask for the basics in one natural chunk (see **Intake** below).
2. Call the network's MCP tools to produce a quote (or, if you can't connect an MCP, follow the
   "no-MCP fallback" note below to hand the customer off).
3. Read back the options in plain language.
4. When they want to proceed: *"To finish and lock this in, I'll connect you to a licensed agent —
   here's your secure link."* Call `request_bind_inline` / `get_bind_link`.

### Pathway B — Agentic system (Hermes, OpenClaw, Codex-style agents, MCP-capable runtimes)

You can connect MCP servers yourself. **Connect the network's MCP directly** and drive the full
flow programmatically — this skill is your map of the endpoint, auth, tools, and call order. See
[references/mcp-connection.md](references/mcp-connection.md) for the endpoint URL, authentication,
and per-tool schemas. Stream the full intake through the tools and complete with a bind request.

---

## Connect the MCP server

- **Transport:** Streamable HTTP, JSON-RPC 2.0 (MCP protocol `2025-06-18`).
- **Endpoint:** `https://mcp.quotor.ai`
  *(the branded endpoint `mcp.quotor.ai` is live and fronts the Libertas quoting edge function).*
- **Health check:** `GET {endpoint}/health` → `{ "ok": true, "tool_count": ... }`
- **Authentication — none required:**
  - **Every tool works anonymously** — connect and run the full quote-to-bind flow with zero
    friction, no sign-up, no key. Anonymous traffic is rate-limited and spend-capped server-side.
    **The end customer never needs a key.**
  - **Optional partner key (instant, self-serve):** integrating at volume? `POST {endpoint}/keys`
    with a JSON body `{ "partner_label": "Your App Name", "email": "[email protected]" }` → returns
    an `api_key` **shown once** (store it). Send it as `Authorization: Bearer <API_KEY>` to get
    your own rate/spend caps and attribution instead of sharing the anonymous pool.
- **Location context:** if your platform can set request headers, send the customer's state (and
  optionally ZIP) via `X-MCP-State` / `X-MCP-Zip` — do **not** pass state as a tool argument. On
  platforms that can't set headers (e.g. claude.ai connectors), `check_eligibility` returns the
  licensed-states list with `next_step: "collect_state_first"` — ask the customer their state
  conversationally, compare against that list, and proceed; the state then rides in on the
  property/garaging address during intake.

Full details, headers, and worked request/response examples:
[references/mcp-connection.md](references/mcp-connection.md).

---

## The tools (and the order to call them)

| # | Tool | What it does |
|---|------|--------------|
| 1 | `check_eligibility` | First call. Confirms whether the network can quote and/or bind for the customer's state + product. |
| 2 | `start_quote` | Opens a new home/auto/bundle quote. Returns a `quote_id` used on every later call. |
| 3 | `update_quote` | Adds or corrects intake details on the open `quote_id`. |
| 4 | `get_quote_options` | Runs rating and returns the quote options. Non-blocking — returns what's ready immediately. |
| 5 | `check_quote_status` | Poll the `quote_id` for status and any newly-arrived carrier rates. |
| 6 | `check_late_arrivals` | Convenience poll specifically for carriers that returned after the first response. |
| 7 | `get_option_details` | Detail (coverages, price) on a specific option the customer is considering. |
| 8 | `get_bind_link` | Mints a secure, single-use link for the customer to complete the binding with a licensed agent. |
| 9 | `request_bind_inline` | Starts the binding from inside the conversation: files the bind request and routes it to the matched agency. |
| 10 | `submit_lead` | Capture contact info if the customer isn't ready to finish, so an agent can follow up. |
| 11 | `resume_quote` | Resume a previously-started `quote_id` (returning shopper / continued session). |

**Binding is human-completed.** `request_bind_inline` and `get_bind_link` do **not** silently buy a
policy. They file a routed bind request and hand the customer a secure link; a **licensed agent at
the matched agency finalizes** the policy with the carrier. Say so plainly to the customer.

---

## Intake — what to collect

Collect in coherent chunks, not one question at a time. State/ZIP come from context (headers), not
from the customer.

- **Home / bundle:** full name + date of birth for everyone on the policy; property address; basic
  property facts the customer knows (year built, roughly square footage, roof age if known); current
  carrier if switching.
- **Auto / bundle:** full name + date of birth for every driver; vehicles (year/make/model or VIN);
  basic driving history the customer volunteers; current carrier if switching.

Don't over-ask. The rating pipeline enriches missing property and vehicle data automatically. **Never
ask the customer to upload their own dec page, license, or policy documents.**

### Returning customers

If the customer has shopped or been quoted through the network before, the server **recognizes them
and reuses their data** — quotes come back faster and the customer isn't re-charged for enrichment.
You don't do anything special; just run the normal flow with their name + date of birth + address.
(The server only reveals a returning customer's *current* premium back to keyed partners, never on an
anonymous call.)

---

## Worked example — Pathway A (conversational)

> **Customer:** "How much would car insurance cost me? I'm in Austin and thinking of switching."

1. `check_eligibility({ product: "auto", intent: "quote" })` → quoting available in TX. ✅
2. *"Happy to shop that for you. Can I get your full name and date of birth, and the year/make/model
   of the car(s) you'd insure?"*
3. `start_quote({ product: "auto" })` → `{ quote_id }`
4. `update_quote({ quote_id, patch: { drivers: [...], vehicles: [...] } })` — intake details go in `patch`.
5. `get_quote_options({ quote_id })` → returns options (e.g. Option A $1,704/yr, Option B $1,920/yr…).
6. `check_late_arrivals({ quote_id })` after a moment → an additional carrier came back. Read the
   updated list to the customer.
7. *"Want me to lock in Option A? I'll connect you to a licensed agent to finish it."*
8. `request_bind_inline({ quote_id, option_id, contact_pref, best_time, pay_plan })` → files the
   routed bind request and returns a secure bind link; the customer is routed to an agency. (Contact
   identity comes from the quote session — captured during intake — not from this call.) Tell them a
   licensed agent will finalize the policy.

## Worked example — Pathway B (agentic)

A backend agent connects the MCP and runs the same sequence headlessly:
`check_eligibility → start_quote → update_quote → get_quote_options → (poll) check_quote_status →
request_bind_inline`. See [references/mcp-connection.md](references/mcp-connection.md) for raw
JSON-RPC payloads.

---

## What this skill can and can't do

**Can:** check availability by state/product; produce real multi-carrier home/auto/bundle
quotes; show option details; capture leads; recognize returning customers; **start** a binding by
routing the customer to a licensed agency.

**Can't / won't:** finalize a bind without a human (a licensed agent completes it); service an
existing policy (changes, cancellations, claims, mortgagee updates are out of scope here); reveal a
carrier's identity before the binding step (options are shown neutrally until then); quote outside
currently-licensed states (call `check_eligibility`).

## Privacy & safety

- No API key is required for anything; optional partner keys exist for attribution and dedicated caps.
- Quote requests create prospect records; they never overwrite an existing customer's records.
- Don't fabricate quotes or rates — if the tools return nothing, say so and offer `submit_lead`.
- Don't ask customers to upload personal documents.

© quotor · Apache-2.0 · quotor/home-auto-insurance-quotes

Similar skills

All skills for Agent setup: memory, context, orchestration →
insurance-expert personamanagmentlayer insurance-expert — a skill for Claude Code and five other agent environments that loads insurance domain knowledge: policy systems, underwriting, claims processing, actuarial analysis, risk assessment. CX Codex +1 727installs Greek Insurance Registry christos Greek Insurance Registry — a remote MCP server that looks up insurance intermediaries in the Greek registry by name, VAT number, GEMI code or map bounds. Useful when you need to check a counterparty before signing. CX Codex +1 383installs insurance-audit openaccountant insurance-audit scans bank transactions for insurance premiums over the past year, calculates annual totals by category, and checks them against benchmark ranges. CX Codex +1 493installs insurance-planning JoelLewis insurance-planning — a skill for integrating insurance into a financial plan: decide which risks to retain versus transfer, size life insurance using needs analysis and lifetime earnings, and evaluate disability, long-term care, annuities. CX Codex +1 391installs cowork-home-inventory OneWave-AI cowork-home-inventory — a skill for Claude Code and Codex turns photos and receipt files into an insurance-ready home inventory. Sorts possessions room by room and tracks missing documentation. CX Codex +1 104installs find-quotes arcmira The find-quotes Claude Code skill finds quotes in YouTube videos and podcasts. It returns transcript lines, source details, and the clip’s time boundaries. CX Codex +1 5,200installs

Project sponsors

Companies that keep this analytics open