## Objectives

In this section you will learn how to improve the conversational skills of your Conversational AI application by allowing for digressions. To do so, you need to know:

- What the Flow Stack is
- How a change of topic during a conversation is handled in Teneo
- What a Resume Prompt is and how to add it
- How to branch your flow at the beginning of the flow when different responses are required based on information in the user input

Objectives - From FAQs to Conversations - Fundamentals

Objectives

## Conversations
One of the trickiest things in bot design is bringing your various flows together in conversations. It's easy to create a bot that handles a single task, but it is rare that we need a bot that simple. In fact, even when your bot is designed for one task only, users may ask about other things. This is a fundamental difference between GUI design and bot design, for example. In a GUI, users may only interact using the things that are actually there. Conversations, on the other hand, have no obvious borders. So even the smallest bot needs to have at least one extra flow for dealing with inputs falling out of scope.

Another special (and cool) thing about conversations is that users can share information between flows, e.g. if the user wants the bot to suggest a coffee type, which triggers a different flow where the user can order said coffee type. The user does not even need to mention the coffee type again; the bot remembers this information from the previous flow and can simply place the order when requested to.

The good news is that these things are exactly what Teneo is built to help you with.



Teneo has many ways of keeping conversations as natural as possible. For example, just like in regular conversations, users are able to pursue various topics at once, rather than having to stay strictly within the confines of a single flow. As long as outputs are set to be able to handle interruptions, users can trigger one flow, then trigger a second before the first one is finished, then be returned to the first flow to complete it. The following is an example of how this might look:

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: Which coffees do you have? (*the coffee order flow is interrupted*)  
> **Bot**: We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.  
> **Bot**: Let's continue with your order. Which coffee would you like? (*the coffee order flow is resumed*)
> 
> **User**: A flat white, please.  
> **Bot**: Ok, a flat white will be ready for pickup in 5 minutes.

Introduction to Conversations - Learning Journey

Conversations

Teneo manages the active Flows in a flow stack. When a Flow is triggered, it is put on top of the stack, and as soon as it is completed, it will be removed from the stack.

The Flow stack is thus made up of all the Flows that have been triggered but have not yet finished. While inside a Flow, the user can change the context and ask something else. This will trigger a different Flow and put the current one on pause.

You can follow the Flow stack in the [Path](/article/optimize/refine-your-bot/how-to/how-to-use-try-out#try-out-advanced_path) section of your Try Out but also with the icons under the output while talking to the bot.

![Build - Flow stack: raise-fkow.png](//images.ctfassets.net/2vbtnveccz5s/4v99bip47YALndufTonbWz/bab44fc1a11edc5ffc8053516b5ef3b5/raise-flow.png?classes=w30)

## Flow stack and interruptions

Most of the time, there is only one Flow on the stack at a time. The stack may grow higher if an active Flow gets interrupted. This may happen if the user asks for clarification instead of responding to the bot's question, or responds with something that the bot does not understand. In those situations, another Flow will be triggered and put on top of the stack. That Flow is then the active Flow. Once it's completed, Teneo will drop it from the stack, and the interrupted Flow will be back on top and resumed.

You can easily specify if your Flow should remain on the Flow stack if interrupted. Flows are only kept on the stack if the output that was interrupted was set to be [revisitable](/studio/flows/concepts/outputs#revisitability).

## Flow links

In Teneo you can link Flows together, making it possible to combine processes that were implemented in different Flows. 

You can either link to [Sub-Flows](/article/build/flows/concepts/subflows) or to regular Flows. Both result in different behaviour. When linking to a Sub-Flow, the dialogue is handed back when the Sub-Flow has finished processing. 

![linking subflow](//images.ctfassets.net/2vbtnveccz5s/4cKO7MuqeXAqWeJh0CfsSJ/69ea95dc151d2288b7aa6d876a7e8cf4/linking_subflow.png?classes=w60)

This is not the case when linking to regular Flows. When Flow **A** links to another regular Flow **B**, the processing of Flow **A** stops and Flow **B** takes over. When Flow **B** has finished executing, processing ends. 

![linking flows](//images.ctfassets.net/2vbtnveccz5s/2xpMO4oQvrhbHfW4YvqsaQ/fe1d5ed6525d4ed1bbba1b611753f57a/linking_flow.png?classes=w60)

When linking to regular Flows, the triggers and trigger-listeners of the Flow you link to are ignored.

To link to a Flow or Sub-Flow, click the 'Flow' icon in the ribbon. Once added, you can specify which Flow you would like to link to. When linking to a Flow you can specify which variables can be transferred back and forth.

## Flow stack control

Teneo manages the Flow stack automatically for you. You can, however, access and manipulate the Flow stack programmatically using the [Engine scripting API](/studio/scripting/concepts/engine-scripting-api). You may, for instance, force the stack to be cleared in certain situations. More on that [here](/studio/scripting/concepts/engine-scripting-api#clear-the-flow-stack).


Build - Flow stack

The Flow stack

When you build a flow that prompts the user for information you need to decide what should happen if the user doesn't respond to the question as expected. Users might also digress or change the subject.

Here you'll learn how to slightly adjust the [coffee order flow](/getting-started/build-a-slot-filling-flow#create-a-basic-flow) so that it may be interrupted and then resumed with a dedicated prompt to the user to continue the flow where it was left off if the user asked another question instead of immediately responding to which coffee they want.

Let's look at an example:

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: Which coffees do you have? (*the coffee order flow is interrupted*)  
> **Bot**: We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.  
> **Bot**: Let's continue with your order. Which coffee would you like? (*the coffee order flow is resumed*)
> 
> **User**: A flat white, please.  
> **Bot**: Ok, a flat white will be ready for pickup in 5 minutes.

In the conversation above there are two flows at play. First the [coffee order flow](/getting-started/build-a-slot-filling-flow#create-a-basic-flow), and then, in the middle of that flow, the [flow about available coffee types](/getting-started/your-first-flow#create-your-first-flow). These flows are designed independently of each other, and there is nothing inside the flows that link them to each other. In fact, once we've adjusted the coffee order flow to survive interruptions, it may be interrupted by any other flow and still be resumed at the point it was interrupted.

To cater for the conversation above you only need to do two things:

*   Check that the output node in the coffee order flow is prepared to survive interruptions (set it to revisitable).
*   Add a resume prompt (optional).

## Check that the output node is revisitable

To allow the output node to survive interruptions you need to make it __revisitable__. This is how you do that:

1. Open the ['User wants to order a coffee'](/getting-started/build-a-slot-filling-flow#create-a-basic-flow) flow in edit mode.
2. Select the output node 'Ask for coffee type'. This will open the 'output configuration' panel to the right.
3. Located in the 'Resume Prompts' section is the option for 'Allow output to be revisited'. Per default, the option is activated and the limit is set to 2. The limit defines how many interruptions in a row the output node should survive. If you deactivate the option, you will note that a border around the node in the graph appears! This signals that the node is not revisitable.

![handle interruptions](//videos.ctfassets.net/2vbtnveccz5s/7ukucXUSAd4G6G8X1WzIWx/ef5789645d698984e2cdf3536083d192/1.4a_handle_interruptions7.5_desktop.mp4)

!!! There are no clear-cut rules about which flows (or outputs) you should make revisitable. Rather, it's an act of balance. On one hand, you don't want your bot to be annoyingly stubborn. On the other hand, if the interruption happens in the middle of a complex flow, you don't want to drop that flow and force the user to start all over once the interruption is dealt with. Regardless of your design skills, revisitability is something that you are likely to fine-tune once you've gathered some log data with real interactions.

## Interrupt your bot in Tryout!

Now, go ahead and try the revisitability feature in Tryout! When the bot asks which coffee you want, test what happens if you say: 'Which coffees do you have?'.

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?  
> **User**: Which coffees do you have?

## Add a resume prompt (Optional)

If you want your bot to say something slightly different when the output is resumed, you can add a resume prompt. This is how you do that:

1. Select the output node 'Ask for coffee type'.
2. Scroll down to the 'Resume prompts' section on the 'output configuration' panel.
3. Click 'Add' and enter an answer text. For example, `Let's continue with your order. Which coffee would you like?`
4. Hit 'Save'.

![2-resume prompt](//videos.ctfassets.net/2vbtnveccz5s/5f0ew0dgMGy8vxABAAKWLB/097f6551505896547afda2254cd63a41/2-resume_prompt.mp4)

## Interrupt your bot again!

Have another play in Tryout. What happens now if you say 'Which coffees do you have' instead of replying to the prompt for type of coffee?

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: Which coffees do you have? (*the coffee order flow is interrupted*)  
> **Bot**: We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.  
> **Bot**: Let's continue with your order. Which coffee would you like? (*the coffee order flow is resumed*)
> 
> **User**: A flat white, please.  
> **Bot**: Ok, a flat white will be ready for pickup in 5 minutes.


Handle Interruptions

Interrupt your bot!

Junctions help you to model the layout and logic of your flow. Multiple transitions can point to the same junction, or a junction can be the starting point of multiple transitions.

![1-junction](//images.ctfassets.net/2vbtnveccz5s/XHnK52gdRISpuxKdkSZgk/ab5c0d30fbe054cffb62e4a20112790b/1-junction.png?classes=w30)

Junctions themselves don't do anything. They don't execute scripts, nor do they display an output. They just offer an easy way to model your flow. By following the rules below you will learn how to get the most out of junctions.

## When do we need junctions?
Here we will describe some common cases where junctions are used in flows.

### Branching at the beginning of a flow
If you want to branch immediately after a flow trigger you can do this using a junction. This might be necessary if you have different responses for the channels your bot uses, or for different customer types, or for specialized cases of the user input. In this exercise we show you how to [branch at the beginning of a flow](/studio/flows/how-to/branch-at-the-beginning-of-a-flow).

When you add a branch at the beginning of a flow it looks something like this:

![junctions-flow](//images.ctfassets.net/2vbtnveccz5s/GNCTtF2tccogow2eAKqXu/d249d6434a7f2859c62772871c33b40a/junctions-flow.png?classes=w60)

###  When transitions share part of a condition
In this example the transitions following the junction represent special cases of the main case that leads to the junction.

![most-cases-europe](//images.ctfassets.net/2vbtnveccz5s/4U6edvSUPAQXoCf4t8AUj6/5c36651f86470c1bd213de039d948c50/most-cases-europe.png)

## When can we avoid junctions?
Keep in mind that you can branch directly from an output node without using a junction. Adding junctions in such cases can make your flow harder to manage and also introduce unwanted errors. When adding a simple branch, don't use a junction.

![4-avoid junctions](//images.ctfassets.net/2vbtnveccz5s/51IXeKHqmnm7377IkylaX2/fa65b44f69fcc207a28352c6da6538cf/4-avoid_junctions.png)

Have a look at the [transitions](/studio/flows/concepts/transitions#conditional-or-not) page for another example of correct branching from an output node.

## How do we use junctions correctly?
You can add logical branches to your flows using junction nodes. These branches (transitions) can be assigned a language or script condition, and can also be set to unconditional. Here we describe some basic guidelines to help you use junctions in the best way possible. 

### Tip 1: Incoming transitions that 'get input' must include a Match
Transitions connecting an output to a junction should be set to 'Get input before continuing' and include 'Match'. If a transition has a 'Match' it could use a [language condition](/studio/language-understanding/concepts/language-conditions).

![european-countries-new](//images.ctfassets.net/2vbtnveccz5s/5gJ8tzOj4DoyTlOEycXHtM/32548ea1cdea1aac18e860424d84edb3/european-countries-new.png)

### Tip 2: Leaving transitions must not 'get input'
Make sure the transitions leaving a junction do not use the option 'Get input before continuing'. As junctions typically come after an input is given, doing this will force the user to repeat their input, without being prompted to do it. Causing a risk for the flow being stuck. Toggle this option with the checkbox in the Triggering section of the configuration panel. You can open the configuration panel by clicking on the transition. 

### Tip 3: Use a fallback transition
When multiple transitions leave a junction, use the last transition as a fallback, and make sure it does not have a 'User Intent' in place. In this example, the first three transitions are set to 'Match', and the fourth one, which serves as the fallback transition, is not. None of the four transitions are set to 'Get input before continuing'.

![6-fallback](//images.ctfassets.net/2vbtnveccz5s/1Us2BrUOQVjWjTKiHTwzvn/701bcba3a43309c9b8d359d0bc93df3e/6-fallback.png)

Build - Junctions

There may be cases where we, depending on the input, want to give out different answers. For cases like this, it's important to know how to branch at the beginning of a flow. In this case we want edit previously created flow [User asks about coffees we offer](/getting-started/your-first-flow#create-your-first-flow) to recognize coffee types when mentioned by the user.

> **User:** What kinds of coffees do you serve?  
> **Bot:** We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.
> 
> **User:** Do you serve brewed coffee?  
> **Bot:** Yes, we do indeed serve brewed coffee in our stores!

Here you'll learn how to add a branch at the beginning of your flow and to specify different paths depending on what the user said:

*   if the user asks about coffee types we serve,
*   if the user asks if we serve a specific coffee type,

These are the steps you'll need to take:

* Extend the flow structure:
* Add a junction, and set it to be start-node
* Add one new output node.
* Link the junction to the output nodes
* Populate the output and transition for the coffee type response

The final version of the flow will look like this:  
![final flow](//images.ctfassets.net/2vbtnveccz5s/27viWmjfSaqBdCt4on8Xv0/f81950719f7ee8c2caa3c3912ae93b7d/final_flow.png)

## Open the flow in edit mode

First, you should open or [create](/getting-started/your-first-flow#create-your-first-flow) the 'User asks about coffees we offer' flow in edit mode:

1.  Select the flow 'User asks about coffees we offer' located inside the 'Flows' folder.
2.  Click 'Edit' in the ribbon. The flow will open in a new window.

## Create a new variable

As a first step we need to create a new [flow variable](/studio/flows/concepts/variables#create-a-flow-variable) that will store the coffee type the user mentions.

1. In the flows's main window, move to the 'FLOW' tab, and select 'Variables'.
2.  Add a variable and name it `mentionedCoffee`.
3.  Put `""` in the 'Evaluation Script' field. This initializes the variable with the empty string.

![1-add flow var](//videos.ctfassets.net/2vbtnveccz5s/Gx3pXYjU2JtdAFmN5rgYW/5193f462d0c5ffd531eaa2e36a1e4dd0/1-add_flow_var.mp4)

## Add an After Match to the Intent Trigger

In order to store the coffee type we need to add a After Match to the Intent Trigger. This will take the coffee type from our previously created [entity](/getting-started/create-custom-entities#create-a-coffees-served-entity) and store it inside the flow variable 'mentionedCoffee'.

1. Go back to the flow editor page and select the trigger. This will open the trigger configuration panel to the right.
2. In the configuration panel, go to 'After Match', click 'Add', and click on 'Entity'.
3. Paste in `COFFEES_SERVED` and hit 'Enter' on your keyboard.
4. Click the 'Add Mapping' button.
5. The 'Source' field denotes the value of the NLU variable of the entity 'COFFEES_SERVED' that we want to store. Select 'coffeeType' from the dropdown menu. 
6. The 'Target' field denotes the name of the variable where the extracted value is to be stored. Select 'mentionedCoffee' from the dropdown menu. 

![2-add after match](//videos.ctfassets.net/2vbtnveccz5s/7o3E2rP6Ny7JmIBtIwOAs2/f05c6b7525dce25f8d8754ff5110a137/2-add_after_match.mp4)

## Extend the flow structure

Follow these steps to re-draw the structure of the flow:

1. Add a junction by clicking on the Plus icon above the output node.
2. Hover over 'Continue With' and select a 'Junction'.  
3. Select the Plus icon under the newly created Junction, followed up with 'Split Path' and 'Transaction'.

![3-extend flow structure](//videos.ctfassets.net/2vbtnveccz5s/6vghe5STDlt0covcU5fB4k/4c9b918ce3903c984f36857f1d2efe1d/3-extend_flow_structure.mp4)

## Populate the new output and transition to recognize Coffee types
We will add a different route for when the user mentions their coffee type:

1. Select the new output node, name it: `We serve the coffee type!` and add the following answer text: `Yes, we do indeed serve ${mentionedCoffee}!`.
2. Now we need to make sure this answer is only given when the user is asking for coffee types we serve. Select the transition and name it `Coffee type mentioned and served`.
3. Add a Match for 'Flow Variable'.
4. From the dropdown, make sure 'mentionedCoffee' is selected (it will be chosen by default).
5. Make sure 'Get Input before continuing' is unselected.
6. This transition should be tested first. You can change its order in the 'Triggering' panel: change it to __1__. Notice how the output nodes change place once the ordering is changed.
7. Hit 'Save'.

![4-populate new output and transition](//videos.ctfassets.net/2vbtnveccz5s/5IKQKDpsBOmMUtP1wkcwFt/9dafe63e6683de716e04f73bf8654573/4-populate_new_output_and_transition.mp4)

## Try it out!

Now go ahead, open the 'Tryout' panel and give it a go!

> **User:** What kinds of coffees do you serve?  
> **Bot:** We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.
> 
> **User:** Do you serve brewed coffee?  
> **Bot:** Yes, we do indeed serve brewed coffee in our stores!


From FAQs to Conversations

Conversations

Next page