SimuLife Insurance Platform

Fully Agentic Life Insurance Experience

Comment

What if buying life insurance were as easy as having a conversation?

Traditional life insurance is tedious. Endless forms. Weeks of waiting. Confusing jargon. After watching friends abandon the process entirely, I built SimuLife, a fully agentic insurance platform powered by conversational AI. No forms, no friction. Just talk to an AI that understands what you need.

Core Platform Features

AI-Powered Insurance Flow

SimuLife uses specialized AI agents to handle every aspect of the insurance journey, from customer inquiry to claims processing.

Customer Inquiry → Application → Quote Generation → Underwriting → Premium Payment → Policy Management → Claims Processing

Multi-Agent Architecture

SimuLife is powered by 5 AI Agents. Each agent is designed as an independent node module for seamless scalability across multi-agent runtimes like Amazon Bedrock Agentcore. Each agent's internal logic is controlled at a granular level using LangGraph, enabling precise workflow orchestration and decision-making processes.

  • Customer Service Agent: Main orchestrator managing sessions and routing requests
  • Marketing Agent: Handles customer education, product inquiries, and quotes
  • Underwriting Agent: Assesses risk and issues new policies
  • Policy Management Agent: Administers active policies and beneficiary updates
  • Claims Agent: Processes claims

Dynamic UI That Builds Itself

Here's the revolutionary part: no cluttered interfaces. SimuLife generates UI components exactly when needed. When users ask about coverage, a professional quote card materializes with a quote ID, coverage amount, term length, and premium details. A secure Stripe payment form appears seamlessly when they're ready to buy. When policy access is needed, a complete document is generated with policy number, beneficiaries, and a downloadable PDF button.

The canvas beside the chat updates contextually. No overwhelming dashboards. No unnecessary buttons. The interface literally builds itself around the conversation.

Voice Integration

Users can speak naturally using voice mode, like calling a real insurance agent.

Revolutionizing the Insurance Industry

Industry Transformation

The life insurance industry operates on decades-old processes. Agent commissions consume massive portions of first-year premiums. Underwriting takes weeks. Many people lack life insurance because the process is too complex. SimuLife changes this equation by automating manual processes with AI agents and significantly reducing operational costs.

Breaking Down Barriers

Traditional insurance often excludes people through complex forms, language requirements, and limited accessibility options. SimuLife addresses these challenges with voice interaction for visually impaired and elderly users. AI agents adapt their conversation style based on users' technical knowledge and literacy levels. 24/7 availability means users can manage insurance on their own schedule. These features expand access to previously underserved populations.

Current Limitations and Path Forward

SimuLife is currently a proof of concept that demonstrates the potential of agentic insurance platforms. The implementation only supports term life policies without renewal capabilities. Human-in-the-loop mechanisms haven't been implemented to handle edge cases or complex scenarios where AI agents need expert oversight.

The path forward requires addressing these gaps systematically. Implementing human-in-the-loop systems would ensure quality control and handle exceptions. Regulatory compliance needs careful consideration. The AI models need training on actual actuarial data. They must be integrated with existing insurance backends, reinsurance partners, and medical information bureaus. Additional features like policy renewals, expanded product lines, and industry-standard system connectors would transform this proof of concept into a production-ready platform.

Project Structure

The project is organized in a monorepo structure containing the following modules:

  • frontend/: React 18 application built with Vite and TypeScript. Uses ShadCN UI components. Chat-first interface with canvas for rendering dynamic UI components. Integrates Stripe for payments and supports voice interaction through AssemblyAI and AWS Polly.

  • backend/: AWS Lambda function containing five modular LangGraph agents. Each agent handles a specific domain with its own state machine and decision logic. It integrates with OpenAI and Gemini LLMs and the DynamoDB database. Returns both chat messages and structured UI components based on conversation context.

  • backend_server/: Express development server that simulates the API gateway and wraps the lambda function for local testing.

  • infrastructure/: AWS CDK definitions for all cloud resources. Deploys API Gateway, Lambda function, DynamoDB tables, S3 bucket frontend, CloudFront distribution, and IAM roles through Infrastructure as Code.

Building with Kiro: Spec-Driven Development

Kiro was the core IDE used to plan, build, test, and deploy this project from scratch. Using spec-driven development, I planned and implemented features incrementally. Kiro automated most of the implementation work.

Steering Documents: The Project's DNA

I began the project by writing two Executive Summary documents. One from a Product Manager's perspective. Another from a Technical Lead's viewpoint. These documents envisioned the entire project.

Next, I asked Kiro to create steering documents based on these summaries. These steering documents contained product vision, architecture decisions, coding standards, and project structure. They acted as the project's DNA, which will be referenced in all future conversations with Kiro. They bound and guided the AI agents to the product vision. They kept everything on track throughout development.

From Vision to Reality with Specs

After creating the steering documents, I broke the project into multiple epics. Each epic became its own Kiro spec.

For each spec, the process was consistent. First, I provided Kiro with a high-level feature description. Kiro then generated a comprehensive requirements document. I reviewed and refined it. Next, Kiro produced a detailed design document. This included architecture diagrams, design patterns, and code snippets. After I approved the design, Kiro created a granular task list. Each task was a manageable step.

Finally, Kiro autonomously executed these tasks. It referenced the spec documents throughout. I rarely needed to intervene.

Automated Workflow with Hooks

Hooks in Kiro automate recurring processes at key intervals. I configured two critical hooks.

First, a documentation hook. It updated the steering documents after each spec completion, reflecting all changes made during implementation. This ensured that the core documentation Kiro relied on was always up-to-date.

Second, a security review hook. It scanned the code for exposed credentials before any git commit. It checked for leaked API keys and secrets. This let me confidently push to the public repository.

These hooks eliminated manual recurring tasks by providing reusable prompts and automated actions. They eliminated the need to execute the task or guide Krio manually. The documentation hook was compelling. It created a self-documenting system where documentation never became outdated.

MCP Servers: Enhanced Intelligence

Kiro has built-in support for MCP servers. These provide the LLM access to external tools. The result is improved context and enhanced intelligence.

I configured several MCP servers. For example, Context7 automatically retrieved library documentation during planning and implementation. Sequential-thinking enforced logical reasoning in complex workflows.

The MCP servers ensured Kiro worked with accurate and current information. Kiro accessed the latest documentation instead of relying on potentially outdated training data. It followed current best practices during implementation.

Software Development Reimagined

Building SimuLife with Kiro transformed my development approach. Rather than wrestling with implementation details, I focused on strategy and design. Specs became contracts between human creativity and AI execution.

The spec-driven approach enabled rapid development of a complex, multi-agent insurance platform. Features that typically require months were implemented in weeks. The combination was powerful: structured specs, consistent steering documents, automated hooks, and enhanced MCP capabilities. Together, they created an efficient development workflow. All while ensuring the final product is perfectly aligned with the original vision.

Built With

Share this project:

Updates