What is function calling in AI Agents? A Guide for compliance officers in insurance

Function calling is a way for an AI agent to ask a system to run a specific action, such as looking up a policy, checking a claim status, or creating a case. It lets the model produce structured requests instead of free-form text, so the agent can trigger approved business functions with predictable inputs and outputs.

In insurance, that matters because the model is no longer “guessing” what to do next. It is selecting from controlled actions that your systems expose, which makes oversight, logging, and policy enforcement much easier.

How It Works

Think of function calling like a claims handler using a company form instead of sending an email with vague instructions.

A human handler might say: “Please verify this customer’s coverage and check whether the loss date is within the policy period.”
With function calling, the AI agent does something similar, but in a structured way:

• •It reads the user request
• •It decides which approved function to use
• •It fills in the required fields
• •Your system executes the function
• •The result comes back to the model
• •The model turns that result into a response for the user

The key point is that the model does not directly access your core systems on its own. It proposes an action in a format your application controls, usually JSON. Your backend then validates it before execution.

Example of what that looks like:

{
  "name": "get_policy_details",
  "arguments": {
    "policy_number": "POL-482193",
    "customer_dob": "1982-04-11"
  }
}

For compliance teams, this separation matters. The model can suggest actions, but your application decides whether to allow them, deny them, redact sensitive fields, or require human review.

A useful analogy is a bank teller with access to a limited set of buttons on their terminal. They cannot invent new operations. They can only press approved buttons like “check balance,” “freeze card,” or “print statement.” Function calling gives an AI agent that same controlled interface.

Why It Matters

Compliance officers should care because function calling changes how AI interacts with regulated workflows.

• •

  It creates control points

  • •You can restrict which functions exist.
  • •You can define who can call them and under what conditions.
  • •That gives you policy enforcement before anything reaches production systems.
• •

  It improves auditability

  • •Every requested action can be logged.
  • •You can store the exact function name, arguments, timestamp, user context, and outcome.
  • •That makes investigations and audits much easier than reviewing free-text chat logs.
• •

  It reduces hallucination risk

  • •A model might invent an answer in plain chat.
  • •With function calling, it must rely on real system outputs for critical facts like policy status or claims history.
  • •That lowers the chance of incorrect customer communications.
• •

  It supports least privilege

  • •Different agents can be given different tools.
  • •A claims assistant may read claim status but not modify reserves.
  • •A sales assistant may quote products but not issue coverage decisions.

Real Example

Consider an auto insurer handling FNOL: first notice of loss.

A policyholder messages:
“Can you tell me if my policy covers windshield damage and start a claim?”

An AI agent built with function calling might do this:

1. •Call get_policy_details(policy_number)
2. •Call check_coverage(policy_id, loss_type="windshield_damage")
3. •If coverage applies, call create_claim(policy_id, loss_date, loss_description)
4. •Return a response to the customer with claim number and next steps

A simplified flow could look like this:

{
  "name": "check_coverage",
  "arguments": {
    "policy_id": "AUTO-100992",
    "loss_type": "windshield_damage"
  }
}

If the coverage check returns:

{
  "covered": true,
  "deductible": 250,
  "notes": "Glass coverage included; deductible applies."
}

The agent can respond:

Your policy includes windshield damage coverage. A $250 deductible applies. I’ve started your claim and created reference CLM-88421.

From a compliance standpoint, this is better than letting the model improvise. The answer is grounded in system data, and every step can be reviewed later.

You still need guardrails:

• •Validate inputs before execution
• •Mask personal data where possible
• •Block disallowed actions
• •Require human approval for edge cases
• •Retain logs for audit and dispute handling

That’s the practical difference between a chatbot and an agent used in regulated operations.

Related Concepts

• •

  Tool use

  • •Broader term for letting models interact with external systems.
  • •Function calling is one implementation pattern under this umbrella.
• •

  Structured output

  • •Similar idea where models return data in strict schemas.
  • •Useful when you need predictable machine-readable responses.
• •

  Human-in-the-loop approval

  • •Required when an action has legal or financial impact.
  • •Common for claims decisions, cancellations, refunds, or adverse actions.
• •

  Policy-based access control

  • •Determines which functions an agent can call.
  • •Should align with role-based access and segregation-of-duties rules.
• •

  Audit logging

  • •Records every tool call and response.
  • •Essential for incident review, compliance testing, and model governance

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.