Insurance Broker Tech Stack 2026: Claude + D23.io as the Default

Table of Contents

1. Why Your Insurance Broker Tech Stack Needs a Rebuild
2. The Core Pillars: Claude Agents, D23.io, and MCP Servers
3. Claude Agents for Submissions and Renewals
4. D23.io for Portfolio Analytics and Business Intelligence
5. Wrapping Legacy AMS Systems with MCP Servers
6. Integration Patterns and Real-World Implementation
7. Security, Compliance, and Audit Readiness
8. ROI and Timeline: What to Expect
9. Migration Strategy: Moving from Legacy to Modern
10. Next Steps: Building Your 2026 Tech Stack

---

Why Your Insurance Broker Tech Stack Needs a Rebuild

The insurance brokerage industry is at an inflection point. If you’re still relying on legacy AMS systems, manual data entry, and point-and-click RPA for submissions and renewals, you’re leaving money on the table—and your team is burning out.

Here’s the reality: most brokers operate with a tech stack that hasn’t fundamentally changed since 2015. You’ve got your AMS (Salesforce, Vertafore, or something custom-built), maybe a CRM layer on top, spreadsheets for renewals, email for submissions, and a bunch of manual workarounds to make it all talk to each other. Meanwhile, your competitors are deploying AI agents that handle entire submission workflows in minutes, not days.

The 2026 insurance broker tech stack is different. It’s built around three core components: Claude agents for intelligent workflow automation, D23.io for real-time portfolio analytics and business intelligence, and MCP servers as the glue that connects your legacy systems to modern AI without a rip-and-replace migration.

This isn’t theoretical. Broker Hub reports that Anthropic’s Claude AI delivers 85% productivity gains across enterprise deployments, with measurable improvements in submission speed, renewals processing, and client communication. Industry analysis predicts AI will become the operating system of insurance operations, and brokers who move now will capture disproportionate value.

The good news: you don’t need to rip out your AMS tomorrow. The modern broker tech stack works alongside your existing systems, adding intelligence without requiring a costly, risky overhaul.

---

The Core Pillars: Claude Agents, D23.io, and MCP Servers

Before diving into implementation, let’s establish what each pillar does and why this combination is the default in 2026.

Claude Agents: Your AI Workforce

Claude is Anthropic’s frontier AI model, and it’s purpose-built for the kinds of workflows insurance brokers need to automate. Unlike earlier-generation AI tools, Claude can:

• Read and interpret unstructured data: PDFs, emails, scanned documents, and handwritten forms become processable inputs.
• Maintain context across multi-step workflows: A submission that requires five back-and-forth emails? Claude handles it end-to-end.
• Make judgment calls within guardrails: Risk assessment, coverage recommendations, and exception handling—with human oversight built in.
• Integrate with external systems: Via APIs, webhooks, and MCP servers, Claude can read from and write to your AMS, email, document management, and analytics tools.

For insurance brokers, Claude agents excel at two high-value workflows: submissions and renewals. In submissions, a Claude agent can intake a client request (via email, form, or API), extract key information, query your AMS for similar past cases, draft coverage options, and loop in your underwriting team for final sign-off—all in under 5 minutes. In renewals, Claude can pull a client’s policy from your AMS, compare it to current market rates via D23.io, flag changes in coverage or risk profile, and generate a renewal proposal ready for the client’s signature.

McKinsey’s financial services research shows that brokers deploying AI agents are cutting submission turnaround time by 60–70%, while simultaneously improving accuracy and client satisfaction.

D23.io: Real-Time Portfolio Analytics

D23.io is a modern data platform purpose-built for insurance operations. It sits between your AMS, external data sources (market rates, claims data, risk indices), and your analytics layer, providing real-time visibility into your portfolio.

Where traditional reporting tools (like Apache Superset) require technical setup and custom SQL, D23.io is built for insurance brokers specifically. It ingests your AMS data, enriches it with market context, and surfaces insights via a semantic layer that non-technical brokers and underwriters can query naturally.

For your tech stack, D23.io serves three critical functions:

1. Portfolio Intelligence: Real-time views of your book of business—premium mix, client concentration, claims trends, renewal rates—without waiting for nightly batch reports.
2. Pricing and Rate Benchmarking: Automatic comparison of client policies against current market rates, flagging opportunities to improve margins or competitiveness.
3. AI-Ready Data: D23.io structures your portfolio data so that Claude agents can query it intelligently. Instead of asking your underwriting team “What’s our average premium for tech startups in Sydney?”, your Claude agent queries D23.io directly and gets an instant answer.

PADISO’s $50K D23.io consulting engagement demonstrates how a typical rollout works: architecture design, semantic layer configuration, dashboard building, and training—all delivered in 6 weeks with measurable ROI from day one.

MCP Servers: The Bridge to Legacy Systems

MCP (Model Context Protocol) is an open standard developed by Anthropic for connecting AI models to external tools and data sources. In the context of your insurance broker tech stack, MCP servers act as adapters that let Claude agents safely query and update your legacy AMS without requiring API changes or deep system integration.

Think of an MCP server as a lightweight wrapper around your AMS. It exposes specific functions—“get client by ID”, “list open renewals”, “update policy status”—in a standardized format that Claude understands natively. Your AMS doesn’t change. Your security posture doesn’t weaken. But Claude can now read and write to your core system as if it were a first-class API.

This is critical because most insurance brokers run on legacy systems (Vertafore, Salesforce Insurance Cloud, or custom builds) that weren’t designed for AI integration. MCP servers let you bridge that gap without a costly, risky migration.

---

Claude Agents for Submissions and Renewals

Let’s get concrete. Here’s how Claude agents transform the two highest-friction workflows in insurance brokerage.

Submissions: From Email Chaos to Structured Workflow

Today, a typical submission workflow looks like this:

1. Client emails your broker with a coverage request (often with attachments, unclear requirements, or incomplete info).
2. Broker manually extracts key details into a form or email.
3. Broker queries the AMS for similar past cases, rate history, and client profile.
4. Broker drafts an email to underwriting with the request and context.
5. Underwriting replies with questions or a quote.
6. Broker loops back to the client with options.
7. Client selects coverage, broker updates AMS, sends policy to client.

This takes 3–7 days. Errors are common (missed details, wrong coverage type, outdated rates). Clients get frustrated.

With Claude agents, the workflow becomes:

1. Client emails your broker (or fills a web form) with a coverage request.
2. Claude agent automatically ingests the email or form, extracts key details, and queries your AMS for context (past policies, claims history, risk profile).
3. Claude cross-references D23.io for current market rates and comparable coverage options.
4. Claude drafts a proposal with 2–3 coverage options, tailored to the client’s risk profile and budget.
5. Claude flags any exceptions or unusual requests and loops in your underwriting team via Slack or email.
6. Underwriting approves or modifies the proposal (Claude can handle simple modifications automatically).
7. Claude sends the proposal to the client with a signature link.
8. Client signs, Claude updates your AMS automatically, and the policy is live.

This takes 20 minutes to 2 hours, depending on complexity. Accuracy improves because Claude is reading the actual client request and cross-referencing your historical data. Clients get faster turnaround and better options.

A practical guide for property and casualty insurance agents shows how Claude handles lead generation, marketing, and client communications at scale, with measurable improvements in response time and conversion rates.

Renewals: Proactive, Data-Driven, Client-Ready

Renewals are often a lost opportunity. Most brokers treat them as a calendar event: “Policy expires on March 15, send renewal notice on March 1.” If the client doesn’t respond, the broker chases them. If there’s been a change in the client’s business or risk profile, it’s often missed until claims time.

Claude agents flip this on its head. A renewal agent can:

1. Proactively flag changes: 90 days before renewal, Claude queries your AMS and D23.io to identify policies that are due for renewal. It automatically checks for changes in the client’s business (new locations, new employees, new revenue streams) by querying external data sources or asking the client directly via a brief questionnaire.

2. Benchmark against market rates: Claude uses D23.io to compare the client’s current premium and coverage against current market rates. If the client is overpaying or underinsured, Claude flags it.

3. Generate a renewal proposal: Based on the client’s risk profile, past claims, and market rates, Claude drafts a renewal proposal with 1–3 options. It highlights any changes in coverage or premium and explains the rationale.

4. Handle the back-and-forth: If the client has questions or wants to modify coverage, Claude can handle simple changes (coverage limit increases, additional insured endorsements) and escalate complex requests to your team.

5. Close the loop: Once the client approves, Claude updates your AMS, generates the renewal policy, and sends it to the client.

The result: renewals that used to take 2–3 weeks now close in 2–3 days. Clients feel proactive and well-served. Your renewal close rate improves because you’re catching renewals before they lapse, and you’re offering better coverage options.

Industry analysis shows that 65% of insurers are planning scaled AI implementations for claims and underwriting, and brokers who deploy Claude agents for renewals are seeing 40–50% reductions in time-to-close.

---

D23.io for Portfolio Analytics and Business Intelligence

Claude agents are the workflow automation layer. D23.io is the intelligence layer. Together, they’re far more powerful than either alone.

Real-Time Portfolio Visibility

Most brokers get portfolio reports once a month (or less frequently). By the time you see that you’re over-concentrated in tech startups or that your claims ratio is trending up, it’s too late to adjust your underwriting strategy or risk profile.

D23.io provides real-time visibility into your entire book of business. You can see:

• Premium mix by industry, geography, and risk type: Are you taking on too much tech startup risk? D23.io shows you instantly.
• Claims trends and loss ratios: Real-time aggregation of claims data from your AMS and external sources, so you can spot adverse trends before they hit your bottom line.
• Renewal pipeline and close rates: Which policies are renewing soon? Which renewals are at risk? What’s your historical close rate by segment?
• Client concentration and retention: Who are your top 20 clients? How has their retention rate trended over the past 12 months?

This visibility lets you make better underwriting decisions. Instead of accepting a new tech startup policy because you don’t know your current exposure, you query D23.io and see that you already have 15% of your premium in tech startups—above your target. You either decline the new business or price it to reflect the concentration risk.

Pricing Intelligence and Rate Benchmarking

D23.io integrates with external data sources—market rate indices, claims databases, risk scoring models—to give you real-time benchmarking data. When a client comes to you asking for a renewal quote, you don’t just pull their past premium and add 5–10%. Instead, you query D23.io to see:

• What the market rate for similar risks is today (vs. when the policy was originally written).
• How the client’s claims history compares to peers in their industry and geography.
• What competitors are likely charging for the same coverage.

This lets you price more competitively and more profitably. You’re not leaving money on the table because you’re underpricing, and you’re not losing clients because you’re overpricing.

AI-Ready Data for Claude Agents

Here’s where D23.io and Claude agents create a virtuous cycle. D23.io structures your portfolio data into a semantic layer—a standardized format that Claude understands natively. Instead of your Claude agent having to parse messy AMS data or run complex SQL queries, it can ask D23.io natural language questions:

• “What’s the average premium for tech startups in Sydney?”
• “Which policies have had claims in the past 12 months?”
• “What’s our renewal close rate for policies over $50K?”

D23.io answers these questions instantly with accurate, real-time data. Claude uses these answers to make better decisions in submissions and renewals.

PADISO’s approach to agentic AI integration with Apache Superset shows how to let Claude query your dashboards naturally, enabling non-technical users to access complex analytics without writing SQL or learning a dashboard tool.

---

Wrapping Legacy AMS Systems with MCP Servers

Now, let’s talk about the glue that holds this stack together: MCP servers and your legacy AMS.

Why MCP Servers Matter

Most insurance brokers run on systems that weren’t designed for AI integration. Your AMS might have an API, but it’s often clunky, poorly documented, and requires deep technical knowledge to use. MCP servers solve this by providing a standardized, Claude-native interface to your AMS.

Here’s a concrete example. Your AMS (let’s say Vertafore) has an API endpoint for updating a policy status. But the endpoint requires:

• Authentication with a 30-minute token refresh cycle.
• Specific field mappings (your internal policy ID maps to the AMS “EntityID” field, but only if it’s prefixed with “POL-”).
• Error handling for race conditions (if two updates hit the AMS simultaneously, the second one fails).
• Audit logging to track who made the change and when.

Building Claude to handle all of this directly is complex and error-prone. An MCP server abstracts away these details. It exposes a simple function: update_policy_status(policy_id, new_status). Claude calls this function, the MCP server handles all the complexity, and Claude gets a clean response.

Beyond simplicity, MCP servers provide security and governance. Instead of giving Claude direct API access to your AMS, you control exactly which functions Claude can call and what data it can access. You can add approval workflows, audit logging, and rate limiting at the MCP server level.

Building Your MCP Server Layer

A typical MCP server for an insurance broker AMS exposes functions like:

• Client Management: get_client(client_id), list_clients(filters), update_client(client_id, data).
• Policy Management: get_policy(policy_id), list_policies(client_id), create_policy(data), update_policy(policy_id, data).
• Submissions and Quotes: create_submission(data), get_submission_status(submission_id), update_submission(submission_id, data).
• Renewals: list_renewals_due(days_ahead), get_renewal_details(policy_id), update_renewal_status(policy_id, status).
• Document Management: upload_document(policy_id, document), list_documents(policy_id), retrieve_document(document_id).

Each function is carefully designed to be:

• Narrow in scope: It does one thing well, not ten things poorly.
• Safe by default: It includes validation, error handling, and rate limiting.
• Auditable: Every call is logged with the user, timestamp, and outcome.
• Reversible: Where possible, operations can be undone or corrected.

Building this layer takes 4–8 weeks for a typical AMS, depending on complexity and how well-documented the AMS API is. But once it’s in place, you’ve unlocked the entire modern AI ecosystem for your broker.

Real-World Example: Wrapping Vertafore

Vertafore is one of the most common AMS systems in insurance brokerage. It’s powerful but old, and its API is complex. Here’s how you’d wrap it with an MCP server:

1. Authentication: The MCP server handles Vertafore authentication, token refresh, and session management. Claude never sees credentials.

2. Policy Lookup: When Claude needs to look up a policy, it calls get_policy(policy_id). The MCP server queries Vertafore’s API, translates the response into a clean JSON format, and returns it to Claude.

3. Policy Update: When Claude needs to update a policy (e.g., change coverage limits), it calls update_policy(policy_id, {coverage_limits: {...}}). The MCP server validates the change, checks permissions, logs the audit trail, and updates Vertafore.

4. Error Handling: If Vertafore is temporarily unavailable or returns an error, the MCP server handles the retry logic and returns a meaningful error to Claude (which can then decide whether to retry, escalate, or inform the user).

The result: Claude can work with your Vertafore AMS as if it were a modern, well-designed API. No special knowledge required.

---

Integration Patterns and Real-World Implementation

Now that we’ve covered the three pillars, let’s talk about how they work together in practice.

Pattern 1: Submission-to-Renewal Pipeline

Here’s a real-world flow:

1. Submission Intake: A client emails your broker asking for a quote on general liability coverage. The email is forwarded to a Claude agent via a simple email integration (using Zapier, Make, or a custom webhook).

2. Data Extraction and Enrichment: Claude reads the email, extracts key details (company name, industry, revenue, locations), and queries your AMS via the MCP server for the client’s history. It also queries D23.io for market rates and comparable risks.

3. Proposal Generation: Claude drafts a proposal with 2–3 coverage options, pricing based on D23.io benchmarks and your underwriting guidelines. It flags any unusual aspects (new industry, high revenue growth) for underwriting review.

4. Underwriting Review: The proposal is sent to your underwriting team via Slack with a button to “Approve” or “Request Changes”. Underwriting reviews in 2–4 hours and approves (or requests modifications).

5. Client Delivery: Claude sends the proposal to the client with a signature link. The client signs within 24 hours.

6. Policy Creation: Claude receives the signed proposal, updates your AMS via the MCP server to create the policy, generates the policy document, and sends it to the client. The policy is now live.

7. Renewal Trigger: 90 days before renewal, a scheduled Claude agent queries your AMS for policies due to renew. It identifies this policy and begins the renewal process (see Pattern 2 below).

Total time from submission to policy live: 24–48 hours. Manual effort: 30 minutes (underwriting review). Accuracy: 99%+ (because Claude is reading the actual client request and cross-referencing your data).

Pattern 2: Proactive Renewal Management

Running continuously, a renewal agent:

1. Daily Scan: Every morning, Claude queries your AMS via the MCP server for policies due to renew in the next 90 days. It also queries D23.io for any changes in the client’s risk profile (new locations, revenue changes, claims history).

2. Renewal Proposal: For each policy, Claude generates a renewal proposal with current market rates (from D23.io), updated coverage recommendations, and a summary of any changes. It prioritizes high-value or at-risk renewals for manual review.

3. Client Outreach: Claude sends the renewal proposal to the client via email (or SMS for high-touch clients) with a link to review and approve. It includes a brief questionnaire to capture any changes in the client’s business.

4. Follow-up: If the client doesn’t respond within 7 days, Claude sends a follow-up email. If they still don’t respond after 14 days, Claude escalates to your broker for manual outreach.

5. Approval and Close: Once the client approves, Claude updates your AMS, generates the renewal policy, and sends it to the client. If the client requests changes, Claude handles simple modifications (coverage limit increases) and escalates complex ones.

6. Reporting: Claude generates a daily renewal report for your team: renewals closed, renewals at risk, average close time, and any escalations.

Result: 85%+ of renewals close automatically, 60% faster than manual processes, with zero manual data entry.

Pattern 3: Claims Triage and Risk Assessment

While submissions and renewals are the primary use cases, Claude agents can also handle claims triage and risk assessment:

1. Claims Intake: A client calls or emails to report a claim. Claude ingests the information, queries your AMS for the policy details, and asks clarifying questions (if needed) to understand the scope of the claim.

2. Initial Triage: Claude categorizes the claim by severity and type, queries D23.io for historical claims data on similar risks, and flags any red flags (potential fraud indicators, coverage gaps, policy exclusions).

3. Escalation: Claude sends the claim details to your claims adjuster via Slack or email, with a summary of relevant history and any flags. The adjuster can approve, request more info, or reassign.

4. Follow-up: Claude tracks the claim status and sends periodic updates to the client.

AI automation for insurance claims processing shows how intelligent agents improve efficiency and accuracy in claims handling, with measurable improvements in turnaround time and client satisfaction.

---

Security, Compliance, and Audit Readiness

If you’re building a modern tech stack for insurance brokerage, security and compliance aren’t afterthoughts—they’re foundational.

Data Security and Access Control

Your insurance broker tech stack will handle sensitive client data: policy details, claims history, financial information, and sometimes health or personal details. Security is non-negotiable.

Here’s how the 2026 stack approaches it:

1. MCP Server as Security Boundary: The MCP server is the only interface between Claude and your AMS. You control exactly what data Claude can access and what operations it can perform. You can restrict Claude to read-only access for sensitive data, or require approval for certain operations.

2. Encryption in Transit and at Rest: All data flowing between Claude, your MCP server, D23.io, and your AMS is encrypted. D23.io and your AMS enforce encryption at rest for sensitive data.

3. Audit Logging: Every action Claude takes (reading a policy, updating a client record, creating a submission) is logged with the user, timestamp, action, and outcome. Audit logs are immutable and retained for compliance purposes.

4. Role-Based Access Control: Different Claude agents have different permissions. A renewal agent can read policies and create renewals, but can’t delete policies or access claims data. An underwriting agent can approve submissions but can’t directly update client records.

SOC 2 and ISO 27001 Readiness

If you’re pursuing SOC 2 Type II or ISO 27001 certification (increasingly common for brokers handling sensitive client data), your tech stack needs to support these audits.

The good news: Claude, D23.io, and modern MCP servers are designed with compliance in mind. Both Anthropic and D23.io publish security documentation and are often already SOC 2 certified themselves.

For your broker, the focus shifts to:

1. Documented Policies and Procedures: How do you onboard new Claude agents? How do you review and approve their actions? What’s your incident response process if an agent makes an error?

2. Access Control and Approval Workflows: Certain actions (creating a policy, approving a claim) require human approval. This is built into your MCP server and Claude prompts.

3. Audit Trail and Monitoring: All actions are logged and monitored. You have dashboards and alerts for unusual activity (e.g., a Claude agent suddenly accessing claims data it shouldn’t).

4. Vendor Management: D23.io and your MCP server provider have their own security certifications and SLAs. You document these and include them in your audit.

PADISO’s security audit services (SOC 2 / ISO 27001) via Vanta help brokers achieve audit readiness without the overhead of manual compliance work. The approach is practical: focus on the controls that actually matter (data access, audit logging, incident response) and document them in a way that auditors understand.

Responsible AI and Model Governance

Using Claude agents in insurance means making decisions that affect clients’ coverage and pricing. How do you ensure these decisions are fair, transparent, and explainable?

1. Guardrails and Constraints: Claude agents operate within guardrails defined by your underwriting team. An agent can’t automatically approve a submission over a certain premium threshold without human review. It can’t apply discounts beyond a certain percentage.

2. Explainability: When Claude makes a decision (e.g., recommending a specific coverage option), it includes reasoning. “I’m recommending increased liability coverage because your revenue has grown 50% since last year, and historical claims data for similar-sized companies shows higher exposure.”

3. Human Oversight: High-stakes decisions (new business underwriting, claims approval, renewal pricing) include human review. Claude can handle 80% of routine cases automatically, but humans remain in the loop for edge cases and exceptions.

4. Bias Monitoring: You periodically audit Claude’s decisions to check for bias. Are certain industries or geographies being systematically over- or under-priced? Are renewals for certain demographics being handled differently? If bias is detected, you adjust the guardrails.

---

ROI and Timeline: What to Expect

Let’s talk money. Building a modern insurance broker tech stack requires investment, but the ROI is substantial.

Implementation Timeline

A typical rollout looks like this:

• Weeks 1–2: Discovery and planning. You document your current tech stack, identify high-friction workflows, and define success metrics.
• Weeks 3–6: MCP server development. You build the bridge between Claude and your AMS, with careful attention to security and error handling.
• Weeks 7–8: D23.io setup. You configure D23.io to ingest your AMS data, set up the semantic layer, and build initial dashboards.
• Weeks 9–12: Claude agent development. You build and test the submission agent, renewal agent, and any other custom agents for your workflows.
• Weeks 13–14: Pilot and refinement. You run a pilot with a subset of your team, gather feedback, and refine the agents.
• Week 15+: Rollout and optimization. You roll out to the full team, monitor performance, and continuously optimize.

Total: 3.5–4 months from start to full rollout. During this time, you’re building on your existing tech stack—no rip-and-replace required.

Financial ROI

Here’s a realistic ROI model for a mid-market broker (50–100 staff, $10–50M revenue):

Costs:

• MCP server development: $30–50K
• D23.io setup and configuration: $20–30K (or $50K for a full consulting engagement like PADISO’s offering)
• Claude agent development: $40–60K
• Ongoing hosting, API usage, and maintenance: $5–10K/month

Total Year 1: $95–150K + $60–120K ongoing = $155–270K

Benefits:

• Submission turnaround: From 3–7 days to 24–48 hours. If you process 500 submissions/year, that’s 750–2,000 hours of broker time saved. At $100/hour loaded cost = $75–200K/year.
• Renewal close rate: From 85% to 95%+. If your average renewal premium is $5K and you have 200 renewals/year, that’s an extra $50K in premium captured.
• Underwriting efficiency: 40% reduction in time spent on routine underwriting. If your underwriting team spends 30% of their time on routine work, that’s 624 hours/year saved. At $120/hour = $75K/year.
• Claims processing: 30% faster claims triage and assignment. If you process 200 claims/year, that’s 40 hours saved. Less tangible, but improves client satisfaction.

Total Year 1 Benefits: $200–325K

Net ROI Year 1: $30–170K (depending on implementation cost and team size)

Year 2+: Ongoing benefits continue and expand. You’ve trained your team, optimized the agents, and can expand to new workflows (risk assessment, cross-selling, portfolio analysis). Benefits often grow 20–30% year-over-year as you find new use cases.

For a broker with $50M revenue, this typically translates to a 2–5% improvement in profitability, which is substantial in a margin-constrained industry.

Key Metrics to Track

Once you’ve deployed, measure:

1. Submission Metrics: Average turnaround time, accuracy rate (% of submissions that don’t require rework), client satisfaction score.
2. Renewal Metrics: Close rate, average time to close, premium per renewal, retention rate.
3. Operational Metrics: Hours saved per week, cost per submission, cost per renewal.
4. Financial Metrics: Additional premium captured, cost savings, net ROI.

Track these monthly and compare to your baseline (pre-implementation). After 3 months, you should see clear improvements in submission turnaround and renewal close rate. After 6 months, financial benefits should be measurable.

---

Migration Strategy: Moving from Legacy to Modern

One of the biggest concerns for brokers considering this tech stack: “What about our existing AMS? Do we have to replace it?”

The answer is no. The 2026 approach is additive, not replacive. You keep your AMS as the system of record, and you layer modern AI and analytics on top via MCP servers and D23.io.

Phase 1: Parallel Running (Weeks 1–8)

You build your MCP server and D23.io setup while your team continues using your AMS normally. No one’s workflow changes. You’re building in parallel.

During this phase, you test the MCP server against your AMS in a safe environment, ensuring that reads and writes work correctly and that audit logging is functioning.

Phase 2: Pilot with Subset (Weeks 9–12)

You select a subset of your team (e.g., one underwriter, one broker) and have them use the new Claude agents for submissions and renewals. Your AMS continues to be the system of record; Claude just makes it easier to work with.

During this phase, you gather feedback, fix bugs, and refine the agents. Your team provides input on usability, edge cases, and what’s working and what isn’t.

Phase 3: Gradual Rollout (Weeks 13–24)

You roll out the Claude agents to your entire team, but gradually. Week 1, you enable them for 20% of submissions and renewals. Week 2, 40%. By week 4, 100%.

This gradual approach lets you catch issues early and adjust without disrupting your entire operation. Your AMS is still the system of record; Claude just handles more and more of the workflow.

Phase 4: Optimization and Expansion (Weeks 25+)

Once the core agents are stable, you expand to new use cases: claims triage, risk assessment, cross-selling, portfolio analysis. You also optimize the agents based on real-world usage patterns.

Your AMS remains the system of record, but it’s now wrapped with intelligence. You can eventually consider replacing your AMS if you want to (e.g., moving to a cloud-native platform), but that’s a separate decision and not required for this tech stack to deliver value.

Why This Approach Works

Most brokers avoid modernizing because they’re afraid of disruption. This approach eliminates that fear. You’re not asking your team to change how they work fundamentally. You’re asking them to use smarter tools that make their jobs easier.

Your AMS continues to work exactly as it did before. You’re not replacing it or even modifying it significantly. You’re just adding a layer of intelligence on top.

This is why agentic AI is fundamentally different from traditional automation: it’s flexible, adaptable, and can be deployed incrementally without rip-and-replace risk.

---

Next Steps: Building Your 2026 Tech Stack

If you’re convinced that this tech stack is right for your broker, here’s how to get started.

Step 1: Audit Your Current Stack

Document what you have:

• AMS system (Vertafore, Salesforce, custom build)
• CRM or client management system
• Analytics tools (if any)
• Document management system
• Email and communication tools
• Any existing automation (RPA, Zapier, Make)

Identify your highest-friction workflows: Which processes take the most time? Which have the highest error rate? Which would have the biggest impact if automated?

Step 2: Define Success Metrics

Before you build anything, define what success looks like:

• Submission turnaround time: Target 24–48 hours (vs. current 3–7 days)
• Renewal close rate: Target 95%+ (vs. current 85%)
• Underwriting hours saved: Target 30–40% reduction
• Team satisfaction: Target 8+/10 on ease of use

Document your current baseline for each metric so you can measure improvement.

Step 3: Partner with an Experienced Team

Building this stack requires expertise in:

• Claude and agentic AI (not just LLMs in general)
• Insurance domain knowledge (AMS systems, underwriting workflows, compliance)
• Data engineering (D23.io setup, semantic layer design)
• Security and compliance (audit logging, access control, SOC 2 readiness)

PADISO is a Sydney-based venture studio and AI digital agency that specializes in exactly this: partnering with insurance brokers to build modern tech stacks. We’ve worked with brokers of all sizes, from 10-person startups to 500+ person firms. We understand the workflows, the systems, and the compliance requirements.

We also offer AI Strategy & Readiness services to help you assess your current stack, identify opportunities, and plan your modernization. And if you want to move fast, we can provide CTO as a Service to lead the build and ensure you’re making the right architectural decisions.

Step 4: Start Small, Expand Fast

Don’t try to boil the ocean. Pick one workflow (submissions or renewals) and nail it. Get your team comfortable with Claude agents, refine the process, and measure the ROI.

Once you’ve proven value in one workflow, expand to the next. After 6 months, you’ll have a best-in-class tech stack that’s delivering measurable value.

Step 5: Invest in Your Team

Your team will need training on how to work with Claude agents. They’re not hard to learn—most brokers pick it up in a few hours—but it’s a different way of working.

Invest in training, documentation, and ongoing support. Your team is your biggest asset, and they’ll be the ones using these tools every day.

---

Conclusion: The Insurance Broker Tech Stack of 2026

The insurance brokerage industry is at an inflection point. Brokers who modernize their tech stacks now will capture disproportionate value: faster submissions, higher renewal close rates, better client satisfaction, and improved profitability.

The 2026 default is clear: Claude agents for workflow automation, D23.io for portfolio intelligence, and MCP servers as the bridge to your legacy AMS. This combination is powerful, practical, and proven.

You don’t need to replace your AMS or overhaul your entire operation. You can layer modern AI and analytics on top of your existing systems, incrementally, with minimal disruption.

The question isn’t whether to modernize—it’s whether you’ll do it now or wait until your competitors have already captured the value.

If you’re ready to build, PADISO can help. We’ve helped brokers across Australia modernize their tech stacks, and we know the playbook. Let’s talk about what’s possible for your firm.