Platform Guide

16 sections

Conduet AI Chat Platform Guide

1. Getting Started

What is Conduet?

Conduet is a platform for building, testing, and deploying conversational AI agents. You create agents that can hold intelligent conversations with your users, answer questions from your knowledge base, collect information, make API calls, and guide users through multi-step processes.

Your agents can be deployed as a webchat widget on your website, or connected to messaging platforms like WhatsApp, Facebook Messenger, Instagram, and WeChat.

Creating Your First Project

From the dashboard, click New Project
Give your project a name and description
Choose a framework (see below)
Optionally start from a template to get a head start

Choosing a Framework

Conduet offers three frameworks for building agents:

Agentic -- Best for open-ended, intelligent conversations. The agent uses AI to decide how to respond, which tools to use, and when to search your knowledge base. Think of it as giving your agent a brain and a set of instructions, then letting it figure out the best way to help each user.

Use agentic when:

You want flexible, natural conversations
The agent needs to handle diverse questions
You want the AI to decide when to use tools or search knowledge

Conversation Flow -- Best for structured, predictable conversations. You design the exact flow using a visual canvas with steps and connections. The conversation follows the paths you define.

Use conversation flow when:

You need precise control over the conversation
The interaction follows a specific process (e.g., booking, intake forms)
You want deterministic behavior with no AI surprises

Outbound -- Best for scheduled content publishing. Build pipelines that generate content with AI, route it through an approval workflow, and publish to social channels (LinkedIn, Twitter, email, Slack, Discord, or webhooks) on a schedule.

Use outbound when:

You want to automate content creation and distribution
Posts need human review before publishing (approval queue)
You need scheduled, recurring content across multiple channels

2. Projects

Project Structure

Every project contains:

Workflows -- The conversation flows your agent follows
Knowledge Base -- Documents your agent can search for answers
Variables -- Data stored during conversations
Tools -- External capabilities (API calls, functions, integrations)
Playbooks -- Reusable agent configurations
Widget Config -- How your webchat widget looks and behaves
Global Prompt -- Your agent's personality, goal, and tone
Instructions -- System-level instructions and the opening message

Creating from Templates

Templates give you a pre-built project that you can customize. Select a template when creating a new project to start with a working agent rather than building from scratch.

Importing Projects

You can import projects from JSON exports, including Voiceflow exports. The importer automatically converts the format to Conduet's native schema.

Publishing Versions

When your agent is ready, publish a version to create a snapshot:

Go to Versions in the project sidebar
Click Publish New Version
Add a version note describing what changed
Deploy this version to your channels

Versions let you roll back if something goes wrong -- you always have a history of previous configurations.

3. Workflows

The Visual Canvas

The canvas is where you design conversation flows visually. Each workflow is a collection of steps (nodes) connected by connections (edges).

Steps are the building blocks -- each one does something specific (send a message, ask a question, call an API, etc.)
Connections link steps together to define the flow -- when one step finishes, the conversation moves to the next connected step
Ports are the connection points on each step -- input ports receive flow, output ports send flow to the next step

How Steps Work

Every workflow starts with a Start step. From there, the conversation flows through connected steps in order. Some steps (like conditions and buttons) have multiple output ports, creating branching paths.

Building a Workflow

Open the Canvas for your project
Drag steps from the palette onto the canvas
Connect steps by dragging from an output port to an input port
Configure each step by clicking on it and editing its properties
Test your workflow using the preview panel

Multiple Workflows

A project can have multiple workflows. Use the Handoff step to transfer the conversation from one workflow to another. This is useful for organizing complex agents into logical sections.

4. Step Types

Start

The entry point of every workflow. Every workflow has exactly one start step. Connections from the start step lead to the first step the user encounters.

Agent

A multi-turn conversational AI agent. This is the most powerful step type -- it uses an LLM to have a free-form conversation with the user, with access to tools and your knowledge base.

Use when: You want the agent to handle an open-ended conversation, answer questions intelligently, or use tools dynamically.

See the Agent Steps Deep Dive section below for full details.

Message

Sends a message to the user. Can be scripted (exact text you write) or prompted (generated by AI from a prompt you provide).

Scripted mode: Write the exact message. You can include variables using {variable_name} syntax.
Prompt mode: Provide an AI prompt and the LLM generates the message dynamically.

Use when: Sending greetings, confirmations, instructions, or any static/semi-static content.

Prompt

A simple one-shot LLM call. Sends a prompt to the AI model along with conversation history and stores the response. Unlike the Agent step, this does not support multi-turn conversation or tool use -- it is a single question-and-answer interaction.

Use when: You need a quick AI-generated response without the overhead of a full agent (e.g., summarizing input, classifying intent, generating a response based on context).

Listen

Pauses the conversation and waits for the user to type a message. The user's input is stored in a variable you specify.

Use when: You need to collect a specific piece of information (name, email, question, etc.).

Buttons

Displays interactive buttons that the user can click. Each button can either follow a specific path in the workflow or send text back as the user's response.

Path buttons: Each button leads to a different next step
Text buttons: The button label is sent as the user's message

Use when: Presenting choices, menus, quick replies, yes/no questions.

Card

Displays a rich card with a title, description, optional image, and buttons. Cards are great for presenting a single item with actions.

Use when: Showing a product, article, recommendation, or any content that benefits from visual presentation.

Carousel

Displays multiple cards in a swipeable horizontal layout. Each card has its own title, description, image, and buttons.

Use when: Presenting multiple options side-by-side (products, plans, results).

Condition

Branches the conversation based on variable values. You define paths with conditions, and the conversation follows the first matching path.

Condition operators:

is / is not -- exact match
contains / does not contain -- substring match
greater than / less than -- numeric comparison
is empty / is not empty -- check if variable has a value

You can combine multiple conditions per path using all (AND) or any (OR) logic. An optional else path catches everything that does not match.

Use when: Routing conversations based on user input, variables, or state.

Set

Assigns values to one or more variables. You can set static values or use expressions for dynamic values.

Static: Set greeting to "Hello!"
Expression: Set total to an evaluated expression

Use when: Storing data, initializing values, transforming variables.

Code

Executes JavaScript code during the conversation. You can read and write variables, perform calculations, or run any custom logic.

Use when: Complex logic that cannot be handled by conditions or set steps -- calculations, data transformation, validation.

API

Makes an HTTP request to an external service. You can configure:

URL, HTTP method (GET, POST, PUT, PATCH, DELETE)
Headers and query parameters
Request body (JSON, form data, URL-encoded)
Response mappings to store returned data in variables

Use when: Fetching data from external systems, submitting forms, triggering webhooks, calling third-party APIs.

KB Search

Searches your project's knowledge base using semantic search. The user's message (or a specified query) is compared against your documents to find relevant information.

Use when: You want to search the knowledge base at a specific point in the flow, rather than letting the agent decide when to search.

Parallel

Runs multiple branches simultaneously. Each branch can have its own agent configuration. Results are merged using one of three strategies:

All: Wait for all branches to complete
First: Use the first branch that finishes
Majority: Use the most common result

Use when: You need multiple AI agents to work on the same question in parallel (e.g., research from different angles, then combine results).

Playbook (Step)

Invokes a playbook -- a reusable agent configuration. Input variables are passed in, and the playbook runs until one of its exit conditions is met, at which point the conversation continues along the matching exit path.

Use when: You have a reusable agent behavior (e.g., "collect shipping address") that you want to invoke from multiple places in your workflows.

Supervisor

Orchestrates multiple AI agents. A supervisor agent coordinates work across sub-agents, deciding which agent to delegate tasks to and synthesizing their outputs.

Define sub-agents with their own prompts, tools, and knowledge base access
Set a maximum number of rounds for the orchestration
Optionally summarize the final output

Use when: Complex tasks that benefit from specialized agents working together (e.g., a research agent + a writing agent coordinated by a supervisor).

Handoff

Transfers the conversation to a different workflow. You can map variables from the current workflow to the target workflow and choose whether to preserve conversation history.

Use when: Organizing large agents into multiple workflows, or routing to specialized sub-flows.

Sub-Workflow

Invokes another workflow as a sub-routine. Unlike handoff, the conversation returns to the calling workflow when the sub-workflow completes, with output variables mapped back.

Use when: Reusable workflow segments that should return control to the caller.

Post-Process

Runs post-processing tasks on the conversation after it ends. Available tasks include:

Sentiment analysis -- Determine the user's overall sentiment
Summary -- Generate a conversation summary
Keywords -- Extract key topics
PDF -- Generate a PDF transcript
Transcription log -- Create a detailed log

Use when: You need analytics or artifacts from completed conversations.

End

Marks the end of a conversation path. Optionally displays a final message before closing.

Use when: The conversation is complete and no further steps should execute.

5. Agent Steps -- Deep Dive

The Agent step is the most powerful and flexible step type. It creates a multi-turn conversational AI agent that can think, use tools, and adapt to the user.

System Prompt

The system prompt tells the agent who it is and how to behave. Write clear, specific instructions:

Example:

You are a helpful customer support agent for Acme Corp. Help users with order status, returns, and product questions. Always be polite and professional. If you cannot help with something, let the user know and suggest they contact support@acme.com.

Model Settings

Each agent step can have its own model configuration:

Model: Which AI model to use (e.g., GPT-4o, Claude)
Temperature: Controls randomness (0 = deterministic, 1 = creative, 2 = very random). For support agents, use 0.1-0.3. For creative tasks, use 0.7-1.0.
Max Tokens: Maximum length of each response

Tool Toggles

Agent steps have built-in tools that you can enable or disable:

Knowledge Base -- Search your documents for relevant information
Buttons -- Let the agent present button choices to the user
Cards -- Let the agent display rich cards
Carousels -- Let the agent show multiple cards in a carousel
Web Search -- Let the agent search the web for current information
End Conversation -- Let the agent end the conversation when appropriate

Each toggle includes a description field where you can instruct the agent on when and how to use that tool.

Path Tools

Path tools let the agent decide when to exit the conversation and which path to follow. Define named paths with descriptions, and the agent will choose the appropriate one based on the conversation.

Example: An intake agent might have path tools for "billing_issue", "technical_support", and "general_inquiry" -- the agent classifies the user's need through conversation, then exits along the right path.

Custom Tools

You can attach custom tools (API, function, integration, MCP) to an agent step. The agent will call these tools when it determines they are needed based on the conversation.

Knowledge Base Access

When enabled, the agent can search your knowledge base during the conversation. It automatically formulates search queries based on what the user is asking, retrieves relevant document chunks, and incorporates that information into its responses.

6. Knowledge Base

The knowledge base is your agent's library of information. When users ask questions, the agent searches this library to find relevant answers.

How It Works

You upload documents or provide URLs
Conduet splits your content into chunks
Each chunk is converted into a vector embedding (a numerical representation of its meaning)
When a user asks a question, their query is also converted to an embedding
The system finds the most similar chunks using vector similarity search (RAG)
Relevant chunks are provided to the AI as context for generating a response

Adding Documents

PDF files -- Upload PDF documents. Conduet extracts the text content automatically.

DOCX files -- Upload Word documents. Text and basic formatting are extracted.

URLs -- Provide a web page URL. Conduet fetches and extracts the page content.

Sitemaps -- Provide a sitemap URL. Conduet discovers and imports all pages listed in the sitemap, which is useful for importing entire websites.

Managing Documents

From the Knowledge tab in your project:

View all uploaded documents and their status
See how many chunks each document was split into
Delete documents you no longer need
Test search queries to see what results your agent would find

Best Practices

Keep documents focused -- One topic per document produces better search results than one massive document covering everything
Use clear headings -- Well-structured content helps the chunking algorithm produce meaningful segments
Test your searches -- Use the search tool to verify that common user questions return relevant results
Update regularly -- Remove outdated documents and add new ones as your information changes

7. Variables

Variables store data during a conversation. They are scoped to the project and persist throughout a user's session.

Creating Variables

Go to the Variables tab in your project to create variables. Each variable has:

Name -- How you reference it (e.g., user_name, order_id)
Default value -- Optional starting value

Using Variables in Steps

Reference variables in message content and prompts using curly braces: {variable_name}

Example message: "Hello {user_name}, your order {order_id} is being processed."

Setting Variables

Variables are set in several ways:

Listen step -- User input is stored in the specified variable
Set step -- Explicitly assign values
API step -- Map response data to variables
Code step -- Read and write variables in JavaScript

Expression Mode

In Set steps, you can enable expression mode to evaluate dynamic values rather than setting static text. This is useful for calculations, string concatenation, or conditional values.

8. Tools

Tools extend what your agent can do beyond just conversation. They let your agent interact with external systems, run code, and connect to services.

API Tools

Make HTTP requests to external services. Configure:

Method: GET, POST, PUT, PATCH, DELETE
URL: The endpoint to call
Headers: Authentication tokens, content types, etc.
Parameters: Query parameters or URL parameters
Body: Request payload (JSON, form data, or URL-encoded)
Input variables: Data from the conversation passed to the API
Output variables: Response data mapped back to conversation variables

Example: An API tool that looks up order status by calling your backend API with an order ID and returning the status and tracking number.

Function Tools

Execute custom JavaScript code. Define:

Code: The JavaScript function to run
Input variables: Data passed into the function
Output variables: Data returned from the function

Example: A function tool that calculates shipping costs based on weight and destination.

Integration Tools

Pre-built connectors for third-party services. Configure:

Provider: The service (e.g., Slack, email, CRM)
Action: What to do (e.g., send message, create record)
Credentials: Authentication for the service
Settings: Provider-specific configuration

MCP Tools

Connect to Model Context Protocol (MCP) servers. MCP is an open standard for connecting AI models to external data sources and tools.

Server URL: The MCP server endpoint
Tool name: Which tool on the server to use
Input variables: Data to send to the tool

Attaching Tools to Agents

Once created, tools appear in your project's tool library. You can attach them to:

Agent steps -- The agent decides when to call the tool based on the conversation
API steps -- The tool is called at a specific point in the workflow

9. Playbooks

Playbooks are reusable agent configurations. Think of them as "skill packages" that define how an agent should handle a specific task.

What Is a Playbook?

A playbook contains:

Name and description -- What this playbook does
Instructions -- Detailed instructions for the agent
Model settings -- Which model and parameters to use
Tools -- Which tools the agent can access
Exit conditions -- When and how the playbook should end

Exit Conditions

Each exit condition defines a named outcome with required variables. When the agent determines it has achieved one of these outcomes (and has collected the required variables), it exits the playbook along that path.

Example: A "Collect Shipping Address" playbook might have:

Exit condition "address_collected" (requires: street, city, state, zip)
Exit condition "user_cancelled" (requires: none)

When to Use Playbooks vs Workflows

Use playbooks when:

You have a reusable agent behavior used in multiple places
The task is conversational and open-ended within a defined scope
You want the AI to decide how to accomplish the task

Use workflows when:

You need precise control over each step
The process is linear or has well-defined branches
You want deterministic behavior

The webchat widget is an embeddable chat interface that you add to your website. Customize its appearance and behavior from the Widget tab.

Appearance

Color -- Set the primary color (hex code) that applies to the header, buttons, and accents. You can also define a full color palette with shades from 50 to 900 for more precise control.

Font -- Set a custom font family for the widget text.

Header

Title -- The name shown at the top of the chat window
Image -- A logo or avatar in the header
Hide image -- Remove the header image entirely

Banner

The banner appears at the top of the chat, before any messages:

Title -- Banner heading
Description -- Banner subtitle or welcome text
Image -- Banner image or illustration
Hide -- Remove the banner entirely

Avatar

The assistant's avatar shown next to messages:

Image URL -- Custom avatar image
Hide -- Remove the avatar from messages

Launcher

The button that opens the chat widget:

Type -- icon (chat bubble icon) or label (text button)
Label -- Text shown on the launcher (when type is label)
Image -- Custom launcher icon

Footer

The footer at the bottom of the chat window:

Link text -- Text for the footer link
Link URL -- Where the footer link goes
Hide -- Remove the footer

Position & Spacing

Side -- left or right side of the screen
Side spacing -- Distance from the edge of the screen
Bottom spacing -- Distance from the bottom of the screen

Behavior

Input placeholder -- Placeholder text in the message input field
Persistence -- How chat state is saved between page loads:
- localStorage -- Persists until cleared by the user
- sessionStorage -- Persists until the browser tab is closed
- memory -- Resets on every page load
Streaming disabled -- Turn off real-time streaming (messages appear all at once instead of word-by-word)
AI Disclaimer -- Show a disclaimer about AI-generated content, with customizable text

Render Modes

Widget -- Floating chat widget with launcher button (default)
Popover -- Chat appears as a popover from the launcher
Embedded -- Chat is embedded directly into your page layout

11. Channels

Deploy your agent to multiple messaging platforms. Each channel connects to the same project but adapts to the platform's capabilities.

Webchat

The default channel. Embed the chat widget on your website using the provided JavaScript snippet. No additional setup required.

Connect your agent to WhatsApp Business:

Create a Meta Business account and WhatsApp Business API application
Get your Phone Number ID, Business Account ID, and Access Token
Set a Verify Token (any secret string you choose)
In the Conduet channel settings, enter these credentials
Configure the webhook URL in your Meta Developer portal to point to your Conduet API

Facebook Messenger

Connect your agent to a Facebook Page:

Create a Facebook App and connect it to your Page
Get the Page ID, Page Access Token, and App Secret
Set a Verify Token
Enter these credentials in the Conduet channel settings
Configure the webhook URL in your Facebook App settings

Instagram

Connect your agent to Instagram messaging:

Ensure your Instagram account is a Business or Creator account connected to a Facebook Page
Get the Account ID, Page Access Token, and App Secret from Meta Developer
Set a Verify Token
Enter credentials in the Conduet channel settings
Configure the webhook URL in your Meta Developer portal

WeChat

Connect your agent to WeChat Official Account:

Register a WeChat Official Account
Get your App ID and App Secret from the WeChat admin panel
Set a Token and optional Encoding AES Key
Enter credentials in the Conduet channel settings
Configure the server URL in WeChat admin to point to your Conduet API

Channel Branding

Each channel deployment can have its own branding:

Logo -- Custom logo image
Primary color -- Brand color
Welcome message -- First message sent to new users

12. Analytics

Track how your agent is performing from the Analytics tab.

Metrics

Total conversations -- Number of conversation sessions
Total messages -- Number of messages exchanged (both user and agent)
Resolution rate -- Percentage of conversations that reached a successful conclusion
Average messages per conversation -- How many exchanges a typical conversation takes
Active sessions -- Currently active conversations

How to Interpret

High message counts with low resolution may indicate your agent is struggling to answer questions -- review your knowledge base and prompts
Very short conversations (1-2 messages) might mean users are not finding what they need, or it might mean your agent is efficiently answering simple questions -- check transcripts to understand
Trending metrics help you understand whether changes to your agent are improving or hurting performance

13. Transcripts

View complete conversation histories from the Transcripts tab.

Each transcript shows:

The full message exchange between user and agent
Timestamps for each message
Session information
Any variables that were set during the conversation

Use transcripts to:

Debug agent behavior -- see exactly what the agent said and why
Identify common user questions that your agent handles poorly
Verify that workflows are executing as expected
Train and improve your agent based on real conversations

14. API Keys

API keys authenticate requests to your project's API endpoints. They are used by the webchat widget and any external integrations.

Format

Conduet API keys use the format cdt_ followed by a random string (e.g., cdt_abc123def456). This prefix makes it easy to identify Conduet keys in your codebase.

Creating Keys

Go to Settings in your project
Navigate to the API Keys section
Click Create API Key
Copy the key immediately -- it will not be shown again

Using Keys

Include the API key as a Bearer token in the Authorization header:

Authorization: Bearer cdt_your_api_key_here

Security

Keep API keys secret -- never expose them in client-side code (the widget handles this automatically)
Rotate keys periodically
Delete keys that are no longer in use
Each key is scoped to a single project

15. Model Settings

Configure which AI models your agent uses and how they behave.

Available Models

OpenAI:

GPT-4o -- Most capable OpenAI model. Best for complex reasoning, nuanced conversations, and tasks requiring high accuracy. Recommended as the primary model.
GPT-4o Mini -- Faster and more cost-effective. Good for simpler tasks where speed matters more than capability.

Anthropic:

Claude Sonnet -- Balanced performance and speed. Good for most conversational tasks.
Claude Opus -- Most capable Anthropic model. Best for complex reasoning and detailed responses.

Temperature

Controls the randomness of the AI's responses:

| Value | Behavior | Best For | |-------|----------|----------| | 0.0 - 0.2 | Very consistent, deterministic | Customer support, factual Q&A | | 0.3 - 0.5 | Balanced consistency and variety | General conversation | | 0.6 - 0.8 | More creative and varied | Creative writing, brainstorming | | 0.9 - 1.5 | Highly creative, sometimes unpredictable | Experimental, creative tasks |

Max Tokens

The maximum number of tokens (roughly words) in each AI response. Higher values allow longer responses but increase latency and cost. For most conversational agents, 500-1000 tokens is sufficient. Set higher (2000-4000) for tasks that require detailed explanations.

Retry Configuration

Configure automatic retries for failed AI calls:

Max retries -- How many times to retry (default: 2)
Fallback model -- An alternative model to use if retries fail (e.g., fall back from GPT-4o to GPT-4o Mini)
Backoff -- Milliseconds to wait between retries

Where to Configure

Model settings can be set at multiple levels:

Project defaults -- Apply to all steps unless overridden (Settings page)
Agent step -- Override for a specific agent step
Playbook -- Override for a specific playbook
Supervisor sub-agents -- Each sub-agent can have its own model settings

Lower-level settings override higher-level defaults.

Quick Reference

Common Patterns

FAQ Bot: Start step -> Agent step (with knowledge base enabled and your documents uploaded)

Lead Collection: Start -> Message (greeting) -> Listen (name) -> Listen (email) -> Listen (question) -> API (submit to CRM) -> Message (confirmation) -> End

Customer Support Router: Start -> Agent step with path tools (billing, technical, general) -> Handoff to specialized workflow for each category

Product Recommendation: Start -> Buttons (category selection) -> Agent step (with product API tool and knowledge base) -> Carousel (display products) -> End

Tips

Start simple and iterate -- begin with a basic agent and add complexity as needed
Test frequently using the widget preview
Review transcripts to find gaps in your agent's knowledge
Use variables to personalize conversations
Keep system prompts clear and specific -- vague instructions lead to vague responses
Set appropriate temperature -- lower for factual tasks, higher for creative ones
Use playbooks for reusable behaviors instead of duplicating workflows

Back to Dashboard API Reference