Colyda — An AI Copilot for Insurance Agents

Inspiration

Insurance agents do not lack skill or motivation; they lack time.

A typical agent’s day is fragmented across CRMs, carrier portals, email inboxes, call logs, compliance checklists, and follow-ups. Much of their cognitive energy is spent not on advising clients, but on orchestrating systems that do not communicate with one another.

We were inspired by developer tools like Claude Code, where a single intelligent agent can understand intent, plan actions, interact with real systems, and execute work end-to-end.

We asked a simple question:

What if insurance agents had the same kind of AI copilot that developers now enjoy?

Colyda is our answer.

What it does

Colyda is an AI agent that works alongside an insurance agent, orchestrating their workflow from lead intake to offboarding across real enterprise systems.

Instead of switching between tools, the agent operates through conversation, context, and skills.

Colyda can:

Read and update real CRM data
Aggregate carrier and policy information into a single operational view
Fetch, summarize, and draft client communications such as email, SMS, and call transcripts
Run compliance checks and log regulatory actions
Plan multi-step workflows and request human approval before execution

All of this happens inside a single agent console, where the AI:

Understands the agent’s intent
Builds a step-by-step plan
Executes actions across systems
Explains what it did and why

Colyda does not replace the insurance agent. It removes the operational drag around them.

How we built it

Colyda is designed as an agent-first system rather than a traditional SaaS dashboard.

Architecture Overview

Frontend

Astro with TypeScript
React islands for interactive agent behavior
Chat-centric user interface
Context panels for CRM, carriers, communications, and compliance

CRM Backend

Salesforce Developer Edition
Standard objects such as Contact
Custom objects such as Insurance_Policy__c
OAuth 2.0 via Connected App
Salesforce REST API and SOQL queries

AI Layer

Claude as the agent reasoning engine
Structured prompts for planning, summarization, recommendations, and response drafting
Deterministic JSON outputs for safe execution

Agent Execution Model

Each agent interaction follows a predictable loop:

[ \text{Intent} \rightarrow \text{Plan} \rightarrow \text{Approval} \rightarrow \text{Execution} \rightarrow \text{Audit} ]

This model makes the system explainable, debuggable, and enterprise-safe.

Challenges we ran into

Agent versus platform mindset

It was tempting to build another dashboard. The challenge was committing fully to an agent-first user experience where conversation drives action and the interface supports reasoning.

Salesforce complexity

Salesforce is powerful but opinionated. OAuth configuration, object modeling, pagination, and rate limits required careful design to ensure a smooth agent experience on top of a real enterprise system.

Trust and safety

An agent that can update CRM records or send client communications must be accountable. We designed explicit approval steps, clear explanations, and auditable actions directly into the interface.

Accomplishments that we are proud of

Built a real agent interface rather than a chatbot wrapper
Integrated with actual Salesforce CRM data instead of mock data
Modeled the complete insurance lifecycle from lead to offboarding
Defined a fully specified API contract enabling unambiguous backend implementation
Created a system that insurance agents immediately recognize as practical and valuable

What we learned

Agents are most effective when they own workflows rather than just answering questions.

Enterprise AI requires context awareness, explicit planning, and human-in-the-loop control. CRMs like Salesforce are not obstacles but foundations when integrated thoughtfully.

We also learned that the future of work is not more tools, but fewer interfaces with more intelligence.