Back

AI Agent Platform

A B2B SaaS platform for creating, configuring, testing, and deploying AI agents across different customer-facing channels.

Role
Product Designer
Platform
B2B SaaS · Web · AI
Focus
Product Strategy · UX Architecture · AI Workflows

Context / Role

The product brings multiple parts of the AI workflow into one workspace — from managing agents and business knowledge to defining behavior, testing models, customizing interfaces, and preparing agents for deployment.

My role was to design the end-to-end product experience and turn a technically complex configuration process into a clear, structured workflow that could work for both non-technical users and more advanced teams.

The main challenge was balancing simplicity and control: making agent setup approachable without hiding the flexibility required for more complex use cases.

The Challenge

Making complex AI configuration approachable without removing control

Configuring an AI agent involves multiple connected decisions — from knowledge sources and instructions to model behavior, testing, integrations, and deployment.

The design challenge was to turn this technical system into a product experience that users could understand and manage without hiding the flexibility required for more advanced use cases.

The platform needed to support two different levels of interaction:

  • Guided setup for non-technical users, with clear structure and understandable terminology.
  • Deeper control for advanced users, including model configuration, integrations, testing, and deployment settings.

An equally important part of the experience was communicating what was happening behind the interface. Users needed clear visibility into states such as training progress, retraining requirements, inactive channels, usage limits, missing data, and unapplied configuration changes.

The goal was to make these states not only visible, but actionable — so users could understand what was happening, what required attention, and what to do next.

Playground in the light theme: model choice, temperature slider, AI actions and system prompt next to a live chat previewThe same Playground in the dark theme

Shaping the MVP Before Designing the Interface

Before moving into high-fidelity design, I worked on defining the product’s initial scope and identifying the smallest experience that could deliver meaningful value.

The challenge was not to expose every possible AI capability from the start, but to create a focused entry point that would help businesses launch a useful customer-facing agent quickly.

This stage helped clarify three things:

  • who the MVP was primarily for
  • which use case should define the first release
  • which capabilities were essential at launch and which could be introduced later

Defining the Primary Audience

The platform had the potential to support different business types, but the MVP needed a more focused starting point.

I prioritized e-commerce and website-based businesses, particularly small and medium-sized teams looking to automate customer communication without building a complex support infrastructure.

Defining the Core Use Case

The primary MVP use case became a sales-oriented AI assistant with built-in customer support.

Rather than separating sales and support into different experiences, the agent could:

  • answer product questions
  • support purchase decisions
  • respond to common customer requests
  • remain available directly on the business website

This gave the product one clear entry point: “I want to add an AI assistant to my website and get it working quickly.”
That principle became the foundation for the initial onboarding and configuration flow.

Working board: primary user candidates and the core MVP use case — a sales-driven AI chat with built-in support

Designing the Shortest Path to a Live AI Assistant

The onboarding flow was designed around one key principle: reduce the time between account creation and the first working customer interaction.

Users start by connecting their website or commerce platform. From there, the product automatically prepares the first version of the agent by:

  • collecting relevant website content
  • generating an initial behavior configuration
  • preparing a customer-facing chat experience

Rather than asking users to complete multiple configuration steps before they understand the product, the flow leads them quickly to a working preview of the assistant.

This creates an earlier moment of value: users can see the agent in context before deciding how deeply they want to customize it.

More advanced configuration is introduced afterward, once users already understand what they are building and how changes affect the final experience.

MVP flow: connect a website, create an account, automatic AI setup, and the widget goes live

Building a Flexible Knowledge Foundation

For the agent to provide reliable answers, users needed a clear way to connect and manage the business knowledge it could rely on.

The challenge was to support different types of information without turning knowledge setup into a technical configuration task.

I explored a knowledge structure that could accommodate multiple source types, including:

  • website pages and multi-page crawling
  • files and PDFs
  • sitemaps and URL lists
  • custom text
  • structured Q&A
  • connected workspace content
  • product and merchant data
Knowledge base: dialogs for adding training sources — files, text, links, Q&A, Notion — and a free-plan limit banner

Separating Essential Setup from Advanced Configuration

One of the key scope decisions was determining how much configuration users actually needed before launching their first agent.

For the MVP, I kept the initial setup focused on three essential choices:

  • agent name
  • welcome message
  • basic widget appearance

These settings provided enough control to create a recognizable customer-facing experience without forcing users to understand the deeper AI configuration model from the start.

More advanced controls were intentionally separated from the initial setup and treated as progressive layers, including areas such as:

  • AI model selection
  • agent personality and detailed instructions
  • campaign rules and triggers
  • conditional behavior
  • multi-agent logic
  • external integrations
  • analytics settings

This created a clear hierarchy between what users needed to launch and what they could configure later.

The first experience remained lightweight and supported by sensible defaults, while the product architecture still left room for more advanced control as user needs became more complex.

Chat configuration: the MVP set (name, welcome message, appearance) versus the advanced settings added later

Mapping the Product Architecture

After defining the MVP, I mapped the broader product architecture to understand how the initial onboarding journey could scale into a complete AI agent workspace.

Rather than treating features as separate tools, I looked at how the main product areas should connect across the agent lifecycle — from initial setup and knowledge configuration to testing, deployment, conversations, and ongoing optimization.

The architecture helped me:

  • identify dependencies between product areas
  • separate core MVP workflows from advanced functionality
  • define transitions between setup, testing, deployment, and optimization
  • establish reusable patterns for knowledge, channels, campaigns, and AI configuration
  • keep the product structure scalable as new capabilities were introduced

The result was not a single linear user flow, but a working model of the product ecosystem — showing how different features support the broader lifecycle of creating, configuring, deploying, and improving an AI agent.

Product architecture map: sign-up, knowledge, chat UI and behaviour branching into Playground, Dashboard, Conversations, Contacts, Campaigns, AI Training and Chat Settings

Product Goals

A guided path from first setup to live deployment

The product was shaped around a small set of goals that guided both the MVP and the broader platform structure:

  • Shorten time to first value by helping users create and preview a functional agent quickly.
  • Keep knowledge manageable as sources are added, updated, or retrained.
  • Make testing part of the core workflow before anything reaches customers.
  • Reduce deployment complexity for users without technical expertise.
  • Provide visibility into real interactions, including conversations, topics, sentiment, and generated leads.
  • Support progressive complexity, from a simple website widget to more advanced channels and integrations.
  • Build for scale, allowing the system to grow across multiple agents, workspaces, sources, and integrations.
Getting Started checklist, 25% complete: create the AI chat, train and test, customize, publishThe same Getting Started checklist in the dark theme

User Journey

From business knowledge to a deployed AI experience

Rather than organizing the platform around isolated settings, I structured the experience around the natural lifecycle of an AI agent — from initial setup to deployment and ongoing improvement.

1. Create

Users define the agent, its workspace, and primary purpose.

2. Add Knowledge

Business information is connected through website content, files, structured Q&A, custom text, and external sources.

The goal is to make knowledge easy to add, review, and update without exposing unnecessary technical complexity.

3. Configure & Test

Users define how the agent should behave, adjust its instructions and model settings, and test responses in a dedicated playground before anything reaches customers.

This keeps experimentation separate from the live experience and makes configuration changes easier to validate.

4. Customize

The customer-facing experience can be adapted through messaging, appearance, suggestions, feedback controls, and localization.

The configuration remains connected to a live preview so users can understand how their decisions affect the final interaction.

5. Deploy

Once the agent is ready, users can publish it across supported customer-facing channels and configure the necessary deployment settings.

6. Monitor & Improve

After launch, conversations and analytics provide context around recurring topics, customer sentiment, usage patterns, and potential leads.

These insights create a feedback loop between real customer interactions and future agent improvements.

Create → Train → Test → Deploy → Learn → Improve

User journey in six steps — create, add knowledge, configure and test, customize, deploy, monitor and improve — with a screen for each and the improvement loop

Knowledge Management

One system for different types of business knowledge

Knowledge management became one of the core areas of the product, since the quality of an agent’s responses depends heavily on the information available to it.

The challenge was to support different types of business content without making each source feel like a separate tool or workflow.

Users can add knowledge through multiple source types, including:

  • uploaded documents
  • custom text
  • crawled website pages
  • structured Q&A
  • connected workspace content
  • customer-support data

Each source has its own input flow, while the overall knowledge state remains visible within a shared workspace.

Users can see what sources are connected, understand their volume and processing status, and identify when changes require the agent to be retrained.

This creates a clear separation between managing business knowledge and configuring AI behavior, while giving users visibility into what information is currently available to the agent.

Four knowledge source types: files, text snippets, website crawling and Q&A

Training & Playground

Making AI behavior easier to understand and validate

The Playground was designed as the main environment for testing and refining agent behavior before it reaches customers.

The challenge was to make AI configuration feel less abstract. Instead of separating settings from their outcome, I designed a split-view workspace where configuration stays visible alongside a live conversation.

Users can adjust areas such as:

  • AI model
  • response variability
  • system instructions
  • business-specific context
  • agent actions

Keeping configuration and output within the same workspace creates a direct feedback loop between what the user changes and how the agent responds.

This makes experimentation easier to understand and gives users a safer way to validate behavior before applying changes to the live customer experience.

All channels: chat widget and help page, plus Email, Zapier, Slack, WordPress, WhatsApp, Messenger, Instagram, Zendesk, Salesforce, API and Shopify

Chat Widget Customization

Organizing complex configuration around clear areas of control

The chat widget needed to support a wide range of customization without turning the editor into one long configuration form.

I structured the experience into four focused areas:

  • Content
    Customer-facing messaging and interaction content, including welcome messages, suggested prompts, feedback, notices, timing, and localization.
  • Style
    Visual customization such as theme, brand assets, colors, widget icon, and placement.
  • AI Behavior
    Channel-specific instructions and behavior, with the option to inherit the agent’s existing configuration where appropriate.
  • Embed & Access
    Publishing controls, allowed domains, installation settings, and configuration for authenticated experiences.

A persistent live preview remains visible throughout the editor, allowing users to understand how changes affect the customer-facing experience without constantly switching between configuration and preview modes.

This structure separates content, presentation, AI behavior, and deployment concerns while keeping them within one coherent editing experience.

Widget editor tabs — content, style, AI behaviour, embed and access — beside a persistent live preview

Conversation Review & Improvement

Turning live conversations into actionable feedback

After deployment, teams needed a clear way to understand how the agent was performing in real customer interactions.

I designed the conversation workspace around a master-detail pattern, allowing users to review a large number of interactions without constantly moving between separate screens.

The experience combines:

  • a searchable list of recent conversations
  • the full selected conversation in context
  • relevant metadata and response details
  • filtering for specific interaction types and time periods

Keeping the conversation and its supporting context within the same workspace makes it easier to identify responses that may require additional knowledge, revised instructions, or further testing.

This creates a continuous feedback loop between real customer conversations and future agent improvements.

Chat logs with a selected conversation and the Improve answer panel for writing the expected response

Outcome

A unified experience across the AI agent lifecycle

The final product concept brings agent setup, knowledge management, testing, customization, deployment, and conversation review into one connected experience.

Rather than treating these areas as separate tools, the product structure connects them around the lifecycle of an AI agent — from the first setup to ongoing improvement after launch.

The design created a scalable foundation for:

  • multiple agents and workspaces
  • additional knowledge sources
  • new deployment channels and integrations
  • deeper conversation insights
  • more advanced AI configuration
  • different levels of usage and access

Most importantly, the experience establishes a clear balance between guided workflows and advanced control. Users can start with a simple path to a working agent while deeper functionality remains available as their needs become more complex.

The result is a product structure that makes a technically complex AI system feel more understandable, manageable, and ready to scale.

Reflection

This project reinforced the importance of deciding which complexity users actually need to see and which complexity the product can handle for them. Designing the platform as a connected system helped me balance approachable onboarding with the flexibility required for more advanced AI workflows.

SaaS ProductsView case Panoptick

Panoptick

A website monitoring platform for tracking uptime, incidents, response times, and service health, with configurable alerts and status pages.

Panoptick preview 1Panoptick preview 2Panoptick preview 3
  • Product Design
  • UX Strategy
  • Monitoring
  • Data Visualization