Operators vs Assistants vs Tools

Deepdesk's architecture consists of three key components that work together to create powerful customer service experiences: Operators, Assistants, and Tools. Understanding the distinct role of each component will help you design more effective solutions for your customer service needs.

Key Components

Operators

Operators are regular assistants configured with specific instructions to orchestrate interactions between multiple other assistants. They aren't a distinct type in the Create Assistant UI, but differ in how they're instructed and used. They serve as coordinators in the Deepdesk ecosystem, determining which specialized assistants should respond to a given situation and aggregating their responses.

Key characteristics:

• Configured with instructions to call and coordinate multiple specialized assistants
• Typically triggered by conversation events (new message, accepted, ended)
• Return responses as an array of Assistant Cues
• Filter out irrelevant or empty responses
• Decide which assistants should respond to specific queries
• Present a unified interface to human agents

Assistants

Assistants perform specific tasks or provide specialized information. Each assistant has a defined purpose, from answering product questions to verifying customer identity.

Key characteristics:

• Focused on specific domains or tasks
• Configured with unique instructions and tools
• Can be called directly by human agents (On Demand Assistants)
• Can be called by Operators or other assistants
• Return responses in various formats (Plain Text, JSON, Cues)

Tools

Tools extend the capabilities of assistants by enabling them to perform actions beyond generating text, such as retrieving data, storing information, or integrating with external systems.

Key characteristics:

• Function-specific capabilities (API calls, knowledge retrieval, etc.)
• Called by assistants to accomplish specific tasks
• Each tool has defined parameters and usage patterns
• Not directly accessible to human agents
• Return data that assistants can process and incorporate into responses

Key Differences

Operators vs Regular Assistants

Operators	Regular Assistants
Coordinate multiple assistants	Focus on specific tasks or domains
Return multiple cues in array format	Typically return a single response
Evaluate which assistants to call	Called directly or by operators
Require specialized response formatting	Can use various response formats
Always return responses as Assistant Cues	May return plain text or structured data
Triggered by system events	Triggered by direct calls or operators

Assistants vs Tools

Assistants	Tools
Task or domain focused	Function focused
Can use tools to extend capabilities	Cannot use other tools
Return formatted responses to users/agents	Return data to the calling assistant
Have their own instructions and memory	Have only parameters, no memory
Can be used by other assistants as tools	Used exclusively by assistants

How They Work Together

In the Deepdesk ecosystem, these components form a hierarchical relationship:

┌─────────────────────────────┐
│ Widget, triggering event    │
│ (new message, accept, end)  │
└───────────────┬─────────────┘
                │       ▲
                │       │
                ▼       │
┌─────────────────────────────┐
│ Operator Assistant          │
│ Evaluates conversation      │
└───────────────┬─────────────┘
                │       ▲
                │       │
                ▼       │
┌─────────────────────────────┐
│ Child Assistants            │< ───────────────┐
│ (specialized functions)     │──────────┐      │
└───────────────┬─────────────┘          │      │
                │    ▲                   ▼      │
                │    │            ┌─────────────────────────┐
                │    │            │ Another Child Assistant │
                │    │            │                         │
                │    │            └──────────┬──────────────┘
                ▼    │            ┌─────────────────────────┐
┌─────────────────────────────┐   │ Assistant for Child #2  │
│ Tools                       │   │                         │
│ (external capabilities)     │   └─────────────────────────┘
└─────────────────────────────┘

The flow works as follows:

1. Downward flow (requests):

   • Widget/triggering event initiates the process
   • Operator Assistant calls Child Assistants or Tools
   • Child Assistants may call other Child Assistants or Tools
   • Each Child Assistant can call Tools

2. Upward flow (responses):

   • Tools return data to their respective Child Assistants
   • Nested Child Assistants return responses to their parent Assistants
   • Top-level Child Assistants process all data and return responses to Operator
   • Operator aggregates responses and returns them to the Widget/interface

This bidirectional flow allows for complex hierarchies of assistants, each with its own specialization and toolset, while maintaining a clear path for both requests and responses.

Conversation Events

Deepdesk operators can be triggered by specific conversation events:

conversation-new-message

Triggered whenever a new message is added to the conversation, either by the customer or agent. These operators can:

• Analyze message content for specific keywords or intents
• Provide real-time assistance based on the latest message
• Trigger specialized assistants for immediate help
• Update conversation memory with new information

conversation-accepted

Triggered when an agent accepts a conversation. These operators can:

• Provide initial summaries and context about the customer
• Surface relevant customer history and account information
• Suggest opening messages or greetings
• Prepare specialized assistants relevant to the customer's profile

conversation-ended

Triggered when a conversation is marked as complete. These operators can:

• Generate conversation summaries
• Extract action items for follow-up
• Update customer records with new information
• Record analytics about the conversation
• Create documents or tickets based on conversation outcomes

Profile Configuration

Which operators are called when a conversation event is triggered is configured in Profile Configuration.

When to Use Each Type

Use Operators When:

• You want to coordinate responses from different specialized assistants
• You need to create a unified experience from multiple assistants
• Different types of customer queries require different specialized knowledge
• You want to avoid overwhelming agents with too many assistant options

Use Regular Assistants When:

• You need focused expertise in a specific domain
• A single assistant can handle the entire task
• You want to create modular, reusable components
• You need direct control over the response format

Use On Demand Assistants When:

• Agents should have control over when to get specialized help
• Different agent roles need different specialized assistants

Use Tools When:

• You need to retrieve external data
• You want to store or retrieve conversation memory
• You need to integrate with existing business systems
• You need to validate data against business rules
• You want to extend assistant capabilities without changing their core instructions

Implementation Examples

Multi-Domain Customer Support Example

For a typical customer service scenario handling multiple domains:

1. Operator Assistant: "Customer Support Coordinator"

   • Evaluates all customer questions
   • Calls specialized assistants as needed
   • Returns their responses as cues to the agent

2. Specialized Assistants:

   • "Product Assistant" - Answers product questions using knowledge base
   • "Account Assistant" - Handles account verification and status
   • "Policy Assistant" - Provides information on company policies

3. Tools Used:

   • call_knowledge_assist - Retrieves product information
   • call_api - Checks account status in CRM
   • write_to_memory - Stores verified customer information

Conversation Event Example

For a complete customer interaction lifecycle:

1. conversation-accepted Operator:

   • Retrieves customer profile information
   • Provides agent with conversation starter suggestions
   • Surfaces recent purchase history
   • Prepares relevant knowledge assistants

2. conversation-new-message Operator:

   • Analyzes each message for intent
   • Suggests relevant responses
   • Flags compliance requirements
   • Calls specialized assistants for complex queries

3. conversation-ended Operator:

   • Generates comprehensive conversation summary
   • Tags conversation with resolved issues
   • Creates follow-up tasks
   • Updates customer record

On Demand Workflow Example

For agent-initiated specialized support:

1. Agent Interface:

   • Shows available On Demand Assistants
   • Agent selects "Compliance Assistant" when needed

2. On Demand Assistant:

   • "Compliance Assistant" checks if verification is needed
   • Returns a formatted cue with compliance requirements
   • Appears in the Assistant Updates widget

3. Tools Used:

   • call_api - Checks compliance requirements in database
   • validate - Ensures customer information meets requirements

Best Practices

For Operators

• Keep operator instructions focused on coordination, not domain expertise
• Include clear filtering logic for irrelevant responses
• Maintain a consistent naming convention for returned cues
• Test with various conversation scenarios to ensure proper coordination
• Use parameters to customize which assistants get called
• Configure different operators for different conversation events

For Assistants

• Give each assistant a clear, singular focus
• Write comprehensive descriptions to help operators know when to use them
• Define necessary parameters carefully
• Select appropriate response formats based on their purpose
• Test both standalone operation and integration with operators

For Tool Usage

• Include specific error handling instructions for each tool
• Document expected inputs and outputs clearly
• Chain tools effectively to create complex workflows
• Use memory strategically to maintain context
• Validate data before sending it to external systems

Conclusion

Understanding the distinct roles of Operators, Assistants, and Tools allows you to architect powerful, flexible customer service solutions in Deepdesk. By leveraging the strengths of each component—Operators for coordination, Assistants for domain expertise, and Tools for extended capabilities—you can create seamless, efficient experiences for both your agents and customers.

The conversation event architecture enables you to automate responses at key moments in the customer journey: when conversations begin, as they progress, and when they conclude. This event-driven approach ensures timely, relevant assistance throughout the customer experience.

When designing your system, start by identifying the domains of expertise needed, then create specialized assistants for each domain. Determine which conversation events require operator involvement, and finally, select the appropriate tools to extend your assistants' capabilities. This modular approach creates a scalable architecture that can evolve with your business needs.