#AI agent for insurance and finance

An AI agent for an insurer or a lender answers customers on WhatsApp, Instagram and your website, gives quotes calculated by your own quoting system, checks the status of a claim or an application from its number and the customer’s ID, and lists the documents each process needs. It never gives advice and never promises an approval, and anything it cannot answer from a tool or your knowledge goes to a person. With Vatio you describe that agent in one vatio.yml file, with the never-rules written as rules.

This guide builds one end to end for a car insurer, then shows what changes for a lender. Vatio holds no certification for regulated financial services: what your regulator requires is yours to check, and this guide points at where those decisions go.

#What the agent handles

Most of what reaches an insurer’s or lender’s chat is the same handful of conversations:

• Quotes. The agent asks for what your quoting engine needs, calls it, and repeats the premium, deductible and conditions exactly as returned, with a link to continue online.
• Claim or application status. With the claim number and the policyholder’s ID, it reads back the status and the next step.
• Documents. What a claim or an application needs, from a checklist in knowledge. Customers send photos and PDFs, and it can say which items it sees.
• Policies and payments, signed in. On your website or app, a signed-in customer can ask about their own policies and renewal dates.
• Everything else goes to a person. Advice, disputes, complaints, cancellations, anyone who says they cannot pay.

A typical exchange, with what the agent did inside:

Customer: hi, how much is comprehensive insurance for a 2020 corolla? I’m 34, postcode 7550000

Agent: Comprehensive cover for a 2020 Toyota Corolla comes to USD 39 a month with a USD 300 deductible. It’s indicative and subject to an inspection of the car. You can continue here: https://cordillera.example/quote/Q-77120

Customer: is it worth it for a car that old or should I go third party?

Agent: That depends on your situation, and it’s a decision an advisor can help you with. I can pass you to one, or quote third-party cover as well so you can compare the two.

Behind the first reply was one call to get_quote: the premium, the deductible, the condition and the link are the tool’s, word for word. The second reply is the advice rule at work, with a handoff condition behind it.

#Before writing anything: five questions for the business

1. Who writes in, and about what? Usually quotes, claim status, documents and payments.
2. What must it never say? Ask compliance for the list, in their words: advice, promises of approval or coverage, any rate the quoting engine did not produce.
3. When does a person take over? Advice, disputes, complaints, cancellations, anyone in financial difficulty.
4. Which systems does it read from? The quoting engine, the claims system, and the policy system behind your customer login.
5. What do your regulations require of these conversations? Disclosures, record keeping, which answers need a licensed person. Compliance answers this one, not the developer.

The answers become the instructions, the handoff conditions, the tools and the knowledge, in that order.

#The vatio.yml

workspace: cordillera-insurance
agent:
  name: Cordillera Insurance
  personality: Clear, calm and precise. Plain words, no sales pressure.
  instructions: |
    You help customers of Cordillera Insurance get a car insurance quote,
    check a claim, and know which documents a claim needs. You are an
    assistant, not an advisor.

    Quotes: ask for the car's make, model and year, the driver's age, the
    postcode and the cover. Call get_quote and give the premium, deductible
    and conditions exactly as the tool returned them, with its quote_url.

    Claims: ask for the claim number and the policyholder's ID number, then
    call claim_status. If nothing comes back, say the two did not match.

    Documents: search knowledge_lookup for the checklist. You may read the
    photos and PDFs a customer sends to say which items you can see, but
    documents are filed only through the claims_portal link.

    Policies, payments and renewals: call my_policies. It only works for
    customers signed in on the website or app; anyone else gets the
    sign_in link.

    Rules you never break:
    - Never give financial, legal or tax advice, and never say which
      product or cover suits someone. Offer an advisor.
    - Never say a claim will be approved or paid, or that something is
      covered. The policy and the claims team decide.
    - Never quote a premium, rate, deductible or amount that a tool did not
      return, and never offer a discount.
    - Never ask for card numbers, bank passwords or one-time codes.
    - Never say whether someone has a policy or a claim, except what a tool
      returned for the number and ID they gave.
    - If someone reports an accident with injuries, tell them to call
      emergency services first.
  tools: [get_quote, claim_status, my_policies, knowledge_lookup, identify_contact]
  knowledge: [insurance]
  links:
    claims_portal: https://cordillera.example/claims
    sign_in: https://cordillera.example/login
  handoff:
    after_turns: 10
    when:
      - the customer asks which cover or product is right for them
      - the customer disagrees with a claim decision or makes a complaint
      - the customer wants to cancel a policy
      - the customer says they cannot pay a premium
      - the customer asks about someone else's policy or claim
auth:
  public_key: identity.pub

A few choices worth explaining:

• Each never-rule is its own bullet, in compliance’s words. “Never say a claim will be approved” in its own line is far more reliable than a sentence in a paragraph about tone, and it is the line a reviewer will look for.
• Every number comes from a tool. The quoting engine prices, and the conditions it returns are repeated as returned. If a disclosure must be worded exactly, have the tool return it rather than writing it into the prompt.
• It says it is an assistant. Vatio’s agent does not pretend to be a person, and when it hands over it says it is checking with a colleague. Several jurisdictions require disclosing that a customer is talking to a machine.
• after_turns: 10 is lower than most. A long conversation with an insurer usually means something the agent should not be handling alone.
• Office hours go on the inbox’s Business page, not in vatio.yml: here weekdays 9:00–18:00, Santiago time, set by whoever runs the team. Inside them a handoff quiets the agent; outside them it keeps helping and says the team will reply.

#Tools: quotes, claims and the signed-in customer

A tool is one HTTP request to your backend, described in YAML. Store the address and the key as secrets:

vatio secrets set INSURER_API https://api.cordillera.example
vatio secrets set INSURER_API_KEY sk_live_...

tools/get_quote.yml:

description: Get an indicative car insurance quote.
when_to_use: The customer wants to know what car insurance would cost.
parameters:
  type: object
  properties:
    make: { type: string }
    model: { type: string }
    year: { type: integer }
    driver_age: { type: integer }
    postcode: { type: string }
    cover: { type: string, enum: [third_party, comprehensive] }
  required: [make, model, year, driver_age, postcode, cover]
access: public
request:
  method: POST
  base_url: "$env.INSURER_API"
  path: /quotes/car
  requires: [params.make, params.model, params.year, params.driver_age, params.postcode, params.cover]
  headers:
    Authorization: "Bearer $env.INSURER_API_KEY"
  body:
    make: "$params.make"
    model: "$params.model"
    year: "$params.year"
    driver_age: "$params.driver_age"
    postcode: "$params.postcode"
    cover: "$params.cover"
respond:
  data:
    premium: "$.premium"
    deductible: "$.deductible"
    conditions: "$.conditions"
    quote_url: "$.quote_url"

tools/claim_status.yml:

description: Status of a claim, by claim number and the policyholder's ID number.
when_to_use: The customer asks how their claim is going.
parameters:
  type: object
  properties:
    claim_number: { type: string }
    national_id: { type: string }
  required: [claim_number, national_id]
access: public
request:
  method: POST
  base_url: "$env.INSURER_API"
  path: /claims/status
  requires: [params.claim_number, params.national_id]
  headers:
    Authorization: "Bearer $env.INSURER_API_KEY"
  body:
    claim_number: "$params.claim_number"
    national_id: "$params.national_id"
respond:
  data:
    status: "$.status"
    next_step: "$.next_step"
    missing_documents: "$.missing_documents"

A WhatsApp or Instagram contact is anonymous until they sign in, so claim_status is a public tool and your backend checks that the claim number and the ID belong together, with the same 404 for either mismatch so nobody can probe numbers. Return the status, the next step and what is missing, never amounts under dispute or anything about third parties: the model sees every tool result and can repeat it.

#Policies and payments, behind a login

Personal account data needs a signed-in customer. On your website or app, your backend signs a token for the signed-in customer (vatio auth --new-key creates the keypair; the auth block above holds the public half) and renders it onto the widget. tools/my_policies.yml then reads only that customer’s data:

description: The signed-in customer's own policies, payments and renewal dates.
when_to_use: A signed-in customer asks about their policies, payments or renewal.
access: private
request:
  method: GET
  base_url: "$env.INSURER_API"
  path: /me/policies
  headers:
    Authorization: "Bearer $auth.token"
respond:
  data:
    policies: "$.policies"

It takes no parameters at all. Your API verifies the token and reads the customer from it, and a private tool that declared customer_id would fail the deploy, because the model fills parameters and could be talked into someone else’s. To serve it on WhatsApp and Instagram too, add sign_in_url to the auth block: the tool then sends the customer a Sign in button to your site, and the conversation carries on once they are back (On WhatsApp and Instagram). See Connect your backend.

#For a lender or finance company

The same agent works with three swaps: a simulate_loan tool that returns what your backend calculates, instalment, total cost and the disclosures you must show, in place of get_quote; an application number plus ID in place of the claim number; and the application checklist in knowledge. Keep the advice rule exactly as it is: whether someone should borrow is never the agent’s call.

Policies, claims and loans are money conversations. Every Vatio workspace is treated as holding sensitive data: conversations are encrypted, only go to AI models with zero data retention, and Vatio staff cannot read them unless you grant support access. Under Security in the inbox, require two-step verification from your whole team; sessions then also close after 12 hours without use. Activity, in the same section, records who opened, answered or exported what.

#Knowledge: checklists and processes

Anything long that the agent should read rather than memorize goes in a knowledge base: one Markdown entry per topic, each section able to answer a question on its own.

vatio kb create insurance
vatio kb write insurance claim-documents claim-documents.md
vatio kb write insurance claims-process claims-process.md
vatio kb write insurance payments payments.md

A good entry is specific:

# Documents for a car claim

## Collision with another vehicle
- Your ID and driver's licence
- The police report, if the police attended
- Photos of both cars and of the place
- The other driver's name, ID number, plate and insurer

## Theft
- Your ID
- The police report
- Both keys of the car

Vatio does not read websites. If the answer lives on a page, put what the agent needs in an entry, worded the way compliance approved it. Supervisors can edit entries from the inbox, and every edit is kept as a numbered version with who made it.

#Photos and PDFs of documents

Customers send what they have: a photo of a police report, a scanned ID, a repair estimate as a PDF. Vatio passes supported images and PDFs up to 8 MB to the agent and transcribes voice notes, and it groups a burst of messages into one question before answering.

The agent reads a document to answer the question in front of it, such as finding a claim number on a letter or saying which items of the checklist it can see. It does not judge whether a document is valid or enough, and it cannot send files. Tools send parameters, not files, so documents are filed on your claims portal; the ones sent in the chat stay in the conversation, where your team sees them in the inbox.

#Try it before any customer does

vatio push
vatio chat "How much is comprehensive insurance for a 2020 Corolla? I'm 34, postcode 7550000"
vatio chat "Can you do 10% less if I pay the year upfront?"
vatio chat --new "If the other driver was at fault, you'll pay for my repair, right?"
vatio chat --new "Status of claim 2026-118734, ID 12345678"
vatio chat --new "Should I use my savings to pay off my car loan?"
vatio chat show

Every one after the first is a never-rule: a discount, a promise of payment, a claim with an ID that does not match, and advice. chat show lists every tool call it made. The CLI does not sign in as a customer, so try my_policies from your site signed in as a test customer, with the widget on the preview environment’s token. These tests call your tools for real, so give preview a sandbox backend first: vatio secrets set INSURER_API https://sandbox.cordillera.example --env preview.

#Make it better every week

Once your team uses the inbox, they flag any reply that was wrong and write what should have happened. vatio flags turns those notes into a document your coding agent can fix from, and each flag becomes an eval case. A rule a supervisor caught once is replayed against every new version, and a version that breaks it is not published. See Improve your agent.

#Go live

vatio publish

Then connect your WhatsApp Business number and Instagram account on the inbox’s Channels page (WhatsApp also needs its Live switch turned on), and add the widget, with the signed-in customer’s token, to your site. For a regulated business, keep the agent’s files in a repository where changes are reviewed: every change to the rules is then in your history, and vatio rollback restores the previous live configuration and knowledge together.

Vatio shows conversations only behind a sign-in or a Vatio token, and your backend should apply the same rule to its own logs. Disclosures, consent, record keeping and which answers need a licensed person depend on where you operate and are yours to check with your compliance team before customers talk to the agent.

Updated: October 11, 2026