5 Design Considerations For A Truly Conversational Chatbot
Allow Users To Have A Natural & Convenient Chatbot Conversation.
The aim of this story is to give you some insight into five general errors in chatbot design and offer possible remedies…
It demands much more development hours to create a truly flexible and unstructured conversational interface. On the other hand, it takes far less time, stress and seemingly less risk to have a restrictive and overly structured conversational interface.
The problem with the latter is, common patterns can creep into the conversational experience, such as fallback proliferation, users being locked into a default closing node expecting a very defined response and more.
Avoid Fallback Proliferation
In order to prevent an user from getting stuck in a particular branch of the dialog, the dialog designer often include in the dialog-tree a node with a true or anything_else condition.
If none of the anticipated and defined input patterns are matched, a generic dialog is presented to the user.
The problem here is that the user is not able to digress away from the dialog branch.
Hence trapping the user in this section of the dialog.
As a conversational designer and developer you need to evaluate any branch that uses this approach and ensure digression away from this point is possible.
Should the user at this point enter something which is totally different from what you expect, it might match some other area of the designed dialog.
Instead of responding with a generic ambiguous message or reprompting, you should leverage the work you have done as a whole and attempt to effectively put the rest of the dialog to work in order to address the user’s utterance.
In the final analysis if there is no regression option available, at the root-level of the dialog, an anything else node can be used when all other avenues have failed.
Reconsider Use Of A Default Closing Node
In many instances, the chatbot unilaterally decides an user intent is fulfilled and then defaults to a closing node, stating Was your query resolved? or, how would you rate your experience.
In many instances this closing rating node acts as a safety net which caches the expression of the intent from the user.
Often users cannot digress out of this question as the dialog is considered closed by the chatbot’s conversational flow.
Reconsider these default service rating dialog nodes and use them as a point of convergence where you can ensure the users intent is truly fulfilled. Not only programmatically, but also from an user experience.
Allow the user to digress from this point to a relevant node in the conversation, and then once that is fulfilled, the user can be brought back.
It is also sensible to drop this question completely and use other metrics and measures to determine customer satisfaction.
Test Likely Digression Paths
In most cases testing is done with a single digression, where the conversation returns to the initial node of departure. Consideration needs to be given to possible digression chains.
A digression chain is where a use digresses away from their current node, to another node, which in turn also allows for digression. If this pattern repeats a few times, the user can potentially digress quite far from where the initial digression was detected and initiated.
Here you should consider if you want to bring the user back to the original point of digression, or allow the user to digress in such a way that the dialog is not brought back to a certain point, and complete control is given to the user.
It makes sense to return where digression took place if you were busy performing slot filling or collecting crucial data. The main takeaway here is that if you allow for a chain of digressions, you should test each of these in detail, to allow a smooth conversational transition and flow.
The Current Node Is the Top Priority
The current node in the dailog remains the top priority. Conversational nodes outside the current flow of nodes must only be considered if the current flow cannot address the user’s dialog input.
In particular a node with slots which allow for digression away, needs to bring the user back, and give feedback of what data has been captured and what still needs to be captured.
During slot filling, for instance in the case of a reservation, the chatbot can inadvertently capture the wrong information.
When the chatbot asks, for when can I make the reservation?
And the user responds, By the way, what is the weather for Tomorrow?, the chatbot can take it as the reservations is for tomorrow and not detect the digression the question entails.
In this case, the current node gets priority, and the chatbot must present the user with with something like OK, I have made your reservation for tomorrow. Hence affording the user the opportunity to detect the problem and rectify it in the conversation.
Whilst digressions is a powerful tool, the chatbot should not trigger unintended digressions, which will be very confusing for the user. Again, testing is crucial to ensure that the current dialog is not broken by detecting unintended digression.
Root Nodes And Nodes With Slots
There are always general and random questions an user can ask at any time. Here it makes sense to have a dialog node which allows digression into it, processes the dialog and then goes back to the point in the flow which was in progress.
In cases where the node has slots, you need to anticipate the types of questions the users might want to ask and use those to ensure the slots within that node are filled.
For example, if your user needs to fill out a conversational form, and the node needs to collect information to fill out something like booking or a reservation, you might want to add digression handlers for some of the common question pertaining to the data elements you are trying to capture in the form.
Other random questions, for instance operating hours, store location, company history etc can be located under the root level nodes.
As you have seen, testing the chatbot is of utmost importance. But not by anyone from the extended chatbot team, but rather regular users. Added to this, your choice of chatbot framework is also paramount; for testing and examples in this story I used IBM Watson Assistant.