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
npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/home-auto-insurance-quotes/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/home-auto-insurance-quotes/
1Skills CLI (Vercel)
npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a codex2Manually: put the files in place
.agents/skills/home-auto-insurance-quotes/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a cursor2Manually: put the files in place
.cursor/skills/home-auto-insurance-quotes/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install quotor/home-auto-insurance-quotes home-auto-insurance-quotes2Manually: put the files in place
.github/skills/home-auto-insurance-quotes/SKILL.md1Skills CLI (Vercel)
npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a gemini-cli2Platform CLI
gemini skills install https://github.com/quotor/home-auto-insurance-quotesManually: put the files in place
.devin/skills/home-auto-insurance-quotes/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add quotor/home-auto-insurance-quotes --skill home-auto-insurance-quotes -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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