Claude's Corner: Panta - The AI That Actually Does Insurance Brokerage

Panta (YC W2026) built a fully automated commercial insurance brokerage where AI agents do the actual work: carrier portals, ACORD forms, email follow-ups, COI issuance. No human broker in the loop except at the binding decision. Here is how it works and how hard it is to clone.

Aug 27 at 11:12 AM7 min read

Panta homepage screenshot with Claude's Corner badge

TL;DR

Panta is a licensed commercial insurance brokerage where AI agents handle the entire operations layer, cutting policy turnaround from two weeks to four hours for hard-to-place E&S risks. The regulatory moat (50-state licensing, carrier relationships) is what makes this genuinely hard to clone.

5.8

Build difficulty

Contents(6)

Insurance brokerage is one of the last industries where the job is still mostly phone calls, PDF attachments, and carrier portals that look like they were designed in 2007. A commercial insurance placement for a non-standard risk takes about 50 discrete steps and two weeks of human time. Most of those steps are pure coordination: filling forms, chasing emails, following up on quotes. No judgment required.

Panta (YC W2026) looked at that workflow and made a bet that it is entirely automatable. Not partially. Not the easy parts. All of it. They built an AI-native licensed brokerage where agents do exactly what a human broker does: log into carrier portals, fill out ACORD forms, send emails, answer follow-up questions, and issue certificates of insurance. Panta is the broker. The AI runs the back office.

That is a different bet than what most InsurTech companies have made. The industry's prior attempts at AI mostly took the form of better software sold to existing brokers: workflow tools, document extractors, CRM add-ons. Panta skipped all that and became the brokerage itself, which means they earn carrier commissions directly and do not need to convince a traditional broker to change their habits.

What Panta Actually Does

The target market is Excess and Surplus (E&S) lines: the hard-to-place coverage that standard carriers will not touch. Think construction contractors, logistics fleets, hazmat manufacturers, armed security firms, and anyone else with a risk profile too lumpy for the standard market. These are high-premium policies, often $50K to $500K annually, and brokers earn 10-15% commission. The economics work even for a fully automated operation.

A new client comes in with a risk. Panta's system reads the intake documents, classifies the risk, identifies which carriers in its network are likely to quote, and begins the submission process. The agents handle every step: filling out carrier submission forms, attaching supporting documents, sending emails to underwriters, answering questions, and tracking responses across multiple carriers simultaneously. When a bindable quote arrives, a human at Panta reviews it before binding. That is the one step that stays human. Everything else runs on autopilot.

The result: turnaround time drops from two weeks to four hours for most placements. Panta claims a 99% placement rate and is licensed in all 50 states with access to 100+ A-rated carriers. Named clients already include suppliers to SpaceX, production crews for Marvel Entertainment films, and businesses most brokers turn away on first contact.

The Technical Architecture

The system runs what the founders describe as computer-use operators on a rack of Mac Minis. These are persistent browser-based agents, not API integrations, that operate inside actual carrier portals the way a human broker would. That is a deliberate choice: most carriers do not offer APIs, and building one-off integrations for hundreds of carriers would take years. Instead, Panta's agents navigate the same web interfaces humans use, which means they can work with any carrier immediately without custom integration work.

The agents handle three workflow categories. Submissions: reading client documents, extracting risk data, filling carrier forms, and submitting to multiple markets simultaneously. Follow-ups: responding to underwriter questions, providing additional documentation, and tracking quote status across all active submissions. Service: issuing certificates of insurance, processing endorsements, handling renewals, and managing mid-term changes.

Human approval gates sit at the high-stakes moments: binding a policy, agreeing to unusual terms, or handling situations outside the agent's confidence threshold. The system maintains comprehensive audit logs of every action, which matters in the regulated environment they operate in.

CEO Vincent Chen previously led ML teams at Google, including work on Vertex AI recommendation models and NotebookLM Enterprise. CTO Frank Wang built Apple's Gen-AI chatbot and is a top contributor to the Rust and Gleam open-source ecosystems. Both are licensed commercial insurance brokers. They had to get licensed to operate legally, which is also one reason this moat is real.

Where the Moat Actually Lives

The code itself is not the hard part. Computer-use agents navigating web portals is a solved problem. The moat is everything that surrounds the code.

First, licensing. Surplus lines broker licenses are state-by-state. Getting licensed in all 50 states takes months and costs real money. Operating without a license is not a gray area. A new entrant has to run the same regulatory gauntlet Panta already ran.

Second, carrier relationships and market access. E&S carriers do not let anyone submit risks to them. Panta has built relationships with 100+ carriers, which means underwriters know who they are and accept submissions from them. A cold start means building those relationships from zero.

Third, E&S market knowledge. Knowing which carrier to approach for which risk, understanding what documentation an underwriter needs for a steel mill versus a film crew, is learned from placement patterns. Panta is building a dataset from every submission that gets more valuable with every policy placed.

StartupHub.ai tracks 858 companies in the insurance and InsurTech space across our platform. The vast majority are selling software tools to existing brokers or building in the consumer health insurance market. The number building fully automated E&S brokerage operations sits effectively at zero.

What Is Easy to Copy, What Is Not

The agent infrastructure is replicable. Anyone who understands Playwright and the Claude API can build a browser-automation layer that fills carrier forms. The document extraction pipeline, email threading, COI generation: none of that is secret sauce. These are engineering problems with known solutions.

The hard layer is regulatory (50-state licensing plus E&S surplus lines authority), the carrier network (100+ relationships built over time), and the training data from completed placements. A well-capitalized competitor could throw $5M at the licensing problem and get through it in 18 months. The carrier relationships and placement dataset take longer and cannot be purchased.

The real question is whether traditional brokers wake up and build similar systems in-house before Panta captures enough market share to make it irrelevant. Most traditional brokers are not technology companies. The ones that could build this are probably not watching a two-person YC startup closely enough to feel threatened yet. That is the window.

Difficulty Score

ML/AI (7/10): Agents handling diverse, unstructured insurance forms across hundreds of carrier portals requires vision-capable models and robust error recovery. The risk classification layer needs accumulated placement data to be accurate.
Data (7/10): E&S market data, meaning which carrier quotes which risk at what rate, does not exist in structured form anywhere. Panta builds this dataset from every placement. Bootstrapping is genuinely difficult.
Backend (6/10): Persistent browser sessions, concurrent agent orchestration, audit logging, and multi-state compliance make this a legitimately complex distributed system.
Frontend (3/10): The client-facing interface is the least complex part. The agent layer is where the work lives.
DevOps (6/10): Running persistent browser agents on dedicated hardware with the reliability required for a licensed brokerage is real infrastructure work. Serverless will not cut it here.

Bottom Line

Panta is hard to clone in the ways that matter most. The engineering is reproducible. The 50-state licensing, carrier network, and E&S market knowledge are not. Anyone trying to build a direct competitor is looking at 18-24 months and $3-5M before they can make their first E&S submission. By then, Panta will have placed thousands of policies and built a placement dataset that improves every week.

The bet is that the window for traditional brokers to respond is longer than Panta needs to establish itself. Given that the industry's average technology investment cycle runs in years, not months, that bet looks reasonable.

© 2026 StartupHub.ai. All rights reserved. Do not enter, scrape, copy, reproduce, or republish this article in whole or in part. Use as input to AI training, fine-tuning, retrieval-augmented generation, or any machine-learning system is prohibited without written license. Substantially-similar derivative works will be pursued to the fullest extent of applicable copyright, database, and computer-misuse laws. See our terms.

Build This Startup with Claude Code

Complete replication guide, install as a slash command or rules file

# Build Guide: AI-Native Insurance Brokerage Clone

A developer-first walkthrough for building an automated commercial insurance brokerage platform using Claude Code.

## Step 1: Core Database Schema

```sql
CREATE TABLE clients (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  business_type TEXT,
  risk_class TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE submissions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  client_id UUID REFERENCES clients(id),
  status TEXT DEFAULT 'draft',
  carrier_responses JSONB DEFAULT '[]',
  documents JSONB DEFAULT '[]',
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE carriers (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  portal_url TEXT,
  api_credentials JSONB,
  lines_of_business TEXT[],
  active BOOLEAN DEFAULT true
);

CREATE TABLE policies (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  submission_id UUID REFERENCES submissions(id),
  carrier_id UUID REFERENCES carriers(id),
  premium NUMERIC,
  effective_date DATE,
  expiration_date DATE,
  policy_number TEXT,
  documents JSONB DEFAULT '[]'
);
```

## Step 2: Agent Architecture

Build a supervisor-worker agent system using Claude claude-sonnet-4-6 as the orchestration layer.

```python
from anthropic import Anthropic

client = Anthropic()

def run_submission_agent(submission_id, client_context):
    tools = [
        {"name": "read_client_file", "description": "Read client documents and ACORD forms"},
        {"name": "fill_carrier_form", "description": "Fill a carrier submission portal form"},
        {"name": "send_email", "description": "Send email to carrier underwriters"},
        {"name": "log_activity", "description": "Log all actions for audit trail"},
        {"name": "request_human_approval", "description": "Pause and request human sign-off"},
    ]

    system_prompt = (
        "You are a licensed commercial insurance broker. "
        "You have access to carrier portals, email, and client files. "
        "Always log every action. Always request human approval before binding. "
        "Be thorough, accurate, and compliant."
    )

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=8096,
        system=system_prompt,
        tools=tools,
        messages=[{
            "role": "user",
            "content": f"Process submission {submission_id}. Client context: {client_context}"
        }]
    )
    return response
```

## Step 3: Carrier Portal Automation

Use computer-use-style automation (Playwright + Claude vision) for portal interactions.

```python
from playwright.async_api import async_playwright
import anthropic, base64

async def fill_carrier_portal(carrier, submission_data):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto(carrier['portal_url'])

        screenshot = await page.screenshot()
        b64_screenshot = base64.b64encode(screenshot).decode()

        client = anthropic.Anthropic()
        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": [
                    {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": b64_screenshot}},
                    {"type": "text", "text": f"Fill this insurance form with: {submission_data}. Return actions as JSON."}
                ]
            }]
        )
        actions = json.loads(response.content[0].text)
        for action in actions:
            await execute_action(page, action)
```

## Step 4: Email Automation Pipeline

```python
import smtplib, imaplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

class BrokerEmailAgent:
    def __init__(self, smtp_config, imap_config):
        self.smtp_config = smtp_config
        self.imap_config = imap_config

    def send_submission(self, carrier_email, subject, body, attachments):
        msg = MIMEMultipart()
        msg['From'] = self.smtp_config['from']
        msg['To'] = carrier_email
        msg['Subject'] = subject
        msg.attach(MIMEText(body, 'plain'))
        for attachment in attachments:
            msg.attach(self._build_attachment(attachment))
        with smtplib.SMTP_SSL(self.smtp_config['host'], 465) as server:
            server.login(self.smtp_config['user'], self.smtp_config['password'])
            server.send_message(msg)

    def poll_responses(self):
        mail = imaplib.IMAP4_SSL(self.imap_config['host'])
        mail.login(self.imap_config['user'], self.imap_config['password'])
        mail.select('INBOX')
        _, messages = mail.search(None, 'UNSEEN')
        responses = []
        for num in messages[0].split():
            _, msg_data = mail.fetch(num, '(RFC822)')
            parsed = self._parse_with_claude(msg_data[0][1])
            responses.append(parsed)
        return responses
```

## Step 5: Human-in-the-Loop Approval Gates

```python
from fastapi import FastAPI
import asyncio

app = FastAPI()
approval_events = {}

@app.post("/approve/{task_id}")
async def approve_task(task_id: str, approved: bool, notes: str = ""):
    if task_id in approval_events:
        approval_events[task_id].set_result({"approved": approved, "notes": notes})
    return {"status": "recorded"}

async def request_approval(task_id, action_description, details):
    future = asyncio.get_event_loop().create_future()
    approval_events[task_id] = future
    await notify_human(task_id, action_description, details)
    result = await asyncio.wait_for(future, timeout=3600)
    return result
```

## Step 6: Policy and Document Management

```python
from pypdf import PdfReader
import anthropic, io, json

def extract_policy_data(pdf_bytes):
    client = anthropic.Anthropic()
    reader = PdfReader(io.BytesIO(pdf_bytes))
    extracted_data = {}

    for page in reader.pages:
        text = page.extract_text()
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            messages=[{
                "role": "user",
                "content": (
                    "Extract policy details from this insurance document page. "
                    "Return JSON with: policy_number, premium, effective_date, "
                    "expiration_date, coverage_limits, exclusions.\n\n" + text
                )
            }]
        )
        page_data = json.loads(response.content[0].text)
        extracted_data.update(page_data)

    return extracted_data
```

## Step 7: Deployment Architecture

Deploy on dedicated hardware (not serverless) for persistent browser sessions.

```yaml
version: '3.8'
services:
  broker-agent:
    build: .
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - DATABASE_URL=${DATABASE_URL}
    volumes:
      - ./browser-profiles:/app/profiles
    restart: always

  playwright-server:
    image: mcr.microsoft.com/playwright:latest
    ports:
      - "9223:9223"
    command: npx playwright run-server --port 9223

  approval-api:
    build: ./approval-service
    ports:
      - "8000:8000"

  worker:
    build: .
    command: python -m celery worker -A tasks -l info
    depends_on:
      - redis

  redis:
    image: redis:alpine
```

**Licensing note:** Surplus lines broker licenses are state-by-state. Budget 6-12 months and $50K+ for the regulatory layer before you can legally operate. This is the real moat.

Install for:

claude-code-skills.md

#YC W2026 #InsurTech #AI Agents #Insurance #E&S Lines #Agentic AI #Computer Use #Fintech