Roots
An Agentic AI platform built for insurance, designed around agents instead of dashboards.
Roots wanted an agent-first AI platform that rethinks how people interact with automation. Instead of starting with tools or workflows, users begin by creating and collaborating with a personalized AI agent, making the experience feel intuitive, human, and role-aware from the first interaction.
[RESPONSIBILITIES]
Shaped product strategy and guided UX direction
Wireframing core platform experiences
Designing agent onboarding and training concepts
Admin and operations interface design
Human-in-the-loop workflow planning
Defining scalable UI patterns for enterprise workflows
[ROLE]
Product Design / UX / UI
[DURATION]
Oct 2025 - Dec 2025
Goals
Focus on building an AI experience that puts agents first and is designed for the unique needs of insurance workflows.
Ensure onboarding feels personal, easy to use, and tailored to each user's role right from the beginning.
Turn complex insurance automation into a system that is easy to understand and encourages teamwork.
Make sure the platform supports key tasks such as quoting, handling claims, reviewing documents, and managing daily operations.
Create a platform structure that can grow with organizations and supports users, projects, and permissions as needs change.
Set up clear steps for when to use automation and when to involve human review.
Help users trust AI-assisted decisions by making the process more transparent.
Develop UI patterns that can be reused and will grow with the platform over time.
Research & Discovery
The project began with a core product question: how should AI feel inside an insurance platform?
Most enterprise automation tools begin with dashboards, rules, or workflow builders. Roots wanted to do things differently and make the experience feel more intuitive and human from the start. Instead of making users set up systems right away, the platform focused on a personalized AI agent that users could create, train, and work with directly.
To guide this approach, I mapped out the entire user journey across the product, which included:
Sign up / organization setup
Agent selection or creation
Agent training and workflow configuration
Project and work item management
Human-in-the-loop review
Operational oversight across tenants and users
This process helped define a key product principle: the platform should not feel like just another automation tool. Instead, it should feel like an AI teammate designed specifically for insurance operations.
This distinction was important because the platform was meant to support high-value, sensitive workflows such as:
Quoting support
Claims intake and handling
Document classification and review
Work item routing
Process validation and exception handling
During the discovery phase, it also became clear that the front-end needed to feel conversational and approachable. At the same time, the system had to have a strong operational backbone to meet enterprise needs such as:
Multi-tenant account structures
User roles and permissions
Project-level workflow visibility
Work item tracking and status management
Document uploads and review
Revision history and reprocessing
Provided by Client
Process & Approach
I worked on making a complex insurance product easier to understand, more organized, and more focused on the people using it.
First, I mapped out the whole user journey, starting with creating an AI agent and moving through training, task execution, and review. This helped me see where the product should feel more conversational and where it needed stronger enterprise features for visibility and control.
After that, I focused on designing two connected layers:
1. Agent-First Experience
The main idea behind Roots was that users should interact mostly with the AI agent, not with the tools behind it.
I looked at ways users could:
Create an agent with a name, description, traits, avatar, and context
Add a user introduction so the agent could behave in a more personalized, role-aware way
Start working together with the agent right after setup
Set up insurance tasks in a way that feels more like teaching an assistant than just configuring software
Use the agent as the main way to shape how automation works
This approach made the product more than just a workflow builder. It became a platform where automation felt easier to use, more relevant, and better matched to how insurance teams really work.
2. Admin & Operational Layer
As the platform started being used in real operations, it still needed strong enterprise controls in the background.
I created admin features to support:
Tenant and workspace management
Project and work item oversight
Search, filters, and scalable data views
User management and permissions
Work item details with status, assignment, and reprocessing
Document upload and review
Revision history for visibility and auditability
This layer was especially important because insurance workflows need a high level of accountability. The interface had to make automation feel clear, easy to track, and safe to use.
During the whole process, I focused on:
Clarity over complexity
Scalable enterprise patterns
Trust in AI-assisted workflows
A balance between conversational UX and operational control
Provided by Client
Solution & Outcome
The final product direction gave Roots a more distinctive and strategically unique platform. It was built specifically for insurance and designed to support a modern approach where people and AI work together.
Rather than starting with rigid workflow tools, users begin with a personalized AI agent:
Users create and define an agent around their role or workflow
The agent becomes the center of interaction
Training feels more collaborative and contextual
Automation is presented as something users can shape through the agent, instead of having to set it up through a technical interface.
This approach gave insurance teams a stronger foundation for handling workflows such as:
Quoting support
Claims processing
Document intake and classification
Operational reviews
Task routing and exception handling
To support this experience, I designed an admin system that made the platform scalable and reliable in daily operations:
A centralized layer for tenants, users, and projects
Clear visibility into work items, documents, and statuses
Human-in-the-loop review patterns for oversight and intervention
Revision history and reprocessing controls help build trust and accountability
Together, these ideas helped Roots create a product experience that can:
Streamline insurance workflows
Improve handling speed and accuracy
Reduce operational leakage
Support more efficient quoting and claims processes
Increase trust in AI-assisted decisions
Create a stronger foundation for long-term scalability and profitability
Reflection & Takeaways
Roots was a valuable experience in designing AI for an industry that is both highly structured and high-stakes.
Insurance workflows need more than just speed. They also require clarity, accountability, and trust. Because of this, it was important to design a system where AI did not seem mysterious or hidden. The product had to be easy to use on the surface, while still providing the transparency and control users expect.
The biggest change in this project was shifting from a tool-first approach to focusing on an agent-first mindset. By building the experience around a personalized AI agent, the platform felt more intuitive and human from the beginning, while still handling the complex needs of enterprise insurance operations in the background.
This project showed me that good AI product design relies on balancing several key factors:
Human-centered interaction
Complex workflow orchestration
Enterprise clarity
Operational trust
Domain-specific product thinking