In a few minutes, you will be able to say 'Hello!' to your first solution both in Teneo and online! Let us get started.

## Log in to Teneo Studio

First, you need to log in to Studio. The Studio will open in the tab 'My Work'. This gives you quick access to the things you’re working on. As you have not yet created anything, there will be nothing displayed under this tab.

![1-login](//videos.ctfassets.net/2vbtnveccz5s/7eN8lBAYNP9IRiZupjra5S/c1b5413a0a1df48b7ec931b5a487b7d4/1-login.mp4)

## Create a solution

Building a bot in Teneo means building a solution. A solution is a container for all knowledge, conversational logic, and additional resources that make up your bot.

This is what you need to do to create a solution:

1. Select 'Solutions' in the menu.
2. Click the 'New' button in the upper right corner. This opens a dialog box.
3. Set the language to English. This will be the mother tongue of your bot.
4.  Under 'Solution Content', choose 'Create from Template' and select the latest version of '**Teneo Dialogue Resources English**' from the list. This will boost your bot with lots of pre-built flows. The bot will then, right out of the box, understand and respond to greetings, meta-requests (like 'Can you repeat that?'), feedback (like 'Great!' or 'You are funny') and conversational small talk.
5. Click on 'Next' and fill in a name for your solution, for example `My First Solution`.
6.  Click 'OK'. It may take a couple of minutes for your solution to be created. You will be notified when it’s done.
7.  Open your solution by either double-clicking its name in the Solutions window or clicking on 'Open' when the solution is created.

![2-create first solution](//videos.ctfassets.net/2vbtnveccz5s/2cKUfKlqpCecDx85K45len/fe1cb4ff9d6d2552a1a21bc6605745bb/2-create_first_solution.mp4)

## Hello World!
Now it is time to talk to your bot. The 'Tryout' panel in the main solution window allows you to test your bot and chat with it.

1. If the Tryout panel is not visible, make it appear by clicking the 'Tryout' button on the right side of the window.  

!!! Teneo comes with pre-built Lexical Resources. The Lexical Resources help your bot to understand a specific language, its words, synonyms, and expressions.

2.  Say `Hello` to your bot. The input field is at the bottom of the panel.
3.  Perhaps you can try some other small talk questions too, like:
*   `How are you?`
*   `My name is John`
*   `What is my name?`
*   `I like you`

![3-tryout](//videos.ctfassets.net/2vbtnveccz5s/6zkFuRg5NDZjQi9jVcq7eR/e82b4adb35c2e264a1550edc8a74eefe/3-tryout.mp4)

## Make your bot available online and talk to it

At the beginning of this page, we said that you would be able to say 'Hello' to your bot online. To achieve this, you must first publish your solution. Publishing a solution means that it will be accessible online (via HTTPS) and once published you can connect your bot to various [channels](/resource/channels) such as Slack, Microsoft Teams, and many more!

To publish your solution, follow these steps:

1.  Find the Solution Tab click on it.
2.  Select the 'Publish' button, this will take you to the publish page for your bot.
3.  Click the 'Manage' button and in the drop-down choose 'Publish'.
4.  You might see a warning **Publish to** ***'Default env'*** **stopped with warnings**.  
    ![Teneo - Error when publish](//images.ctfassets.net/2vbtnveccz5s/PIUf2D5xXnRP862Xd9iii/11b4224ed2fe18f0a253eadd5f3ad4f9/publish-error-2.png?classes=w40) 
    This is nothing to worry about, the warning is shown when you publish your solution for the first time or when you have made certain global changes. To proceed, just check the checkbox 'Perform full application deployment on try again' and click the 'Try again' button.

Congratulations, you have made your first solution available online! The next step is to interact with it. There are two ways to interact with a newly published solution; you can either interact with it through a test page or through a chat widget. We are going to show you how to try out your bot through the chat widget, Teneo Web Chat.

1.  Once published, click on the blue 'Open' icon. This will open the Teneo Web Chat in a new browser tab.  

!!! Teneo Web Chat is also available in the [Bots section](/manage/bots) in your team console. You need to publish the bot from Teneo Studio before using it.

2.  Click on the blue icon in the bottom right corner to open up the Teneo Web Chat window.
3.  Go ahead and try some small talk, like:
*   `Hello`
*   `How are you?`
*   `My name is John`
*   `What is my name?`
*   `I like you`

![4-publish](//videos.ctfassets.net/2vbtnveccz5s/6emwZoQ2qKVBOzzROllwqg/e8507007fd4affda349225a315756910/4-publish.mp4)

The chat widget that you just tested is known as [Teneo Web Chat](/resource/channels/teneo-web-chat). This widget can be embedded in websites and supports rich media such as buttons, cards, quick replies, and much more!

It is important to know that when publishing your solution a snapshot of your solution is created. This means that if you update your solution in Teneo, and you wish for your published solution to match the updated version in Teneo, you must republish. To republish follow steps 1-3 above, but instead of choosing ‘Publish’ choose ‘Republish’.

!!! If you want to try out your published solution via the test page, click ‘Open’ in the publication confirmation pop-up. If you have already closed it, you can click the URL shown in the ‘Publish’ window instead. This will open a test page where you can try out your bot.

## Summary

Great job, you've created your very first solution! Let's take a quick recap on what we did in this section:

*   Created a 'Solution' that holds all the conversational logic of the bot.
*   Explored 'Tryout', which allows you to interact and test the bot directly from Teneo.
*   Published a first solution, making it available online.
*   Interacted with the published bot through the Teneo Web Chat front end.


Your First Solution

Now that you have created a solution for your bot, it's time to add your first dialogue. In Teneo, all dialogues are designed as flows. Flows contain the logic needed to resolve a specific question of the user. They can be simple (e.g. a flow that answers the question "What kind of coffee do you have?") or complex (for example, a flow that helps the user order a coffee beverage), but they always represent some kind of pre-defined conversational pattern.

Throughout these pages, we will create a bot for Longberry Baristas, a very hip (yet fictitious) coffee bar. We will start with a simple flow to handle the following conversation:

> **User:** What kind of coffee do you have?  
> **Bot:** We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.

To achieve this we will do the following:

*   Create a folder in which we can store our flow.
*   Add a new flow.
*   Provide example inputs to recognize the user's intent.
*   Generate a Match based on the provided example inputs.
*   Add an answer text.
*   Save and test our flow.

The result will look like this:  
![final flow](//images.ctfassets.net/2vbtnveccz5s/4ghVs7d1oOmwBljQxpsiBU/95c287d1bb02723467adaf8e3744169e/final_flow.png)

Before you continue, make sure you are logged in to Studio and have opened the solution you created earlier.

## Create a 'Flows' folder

Flows are stored in folders. In the 'Explore' section, you will see several folders with flows that came out of the box. These flows make sure your bot will understand and respond to greetings, meta-requests (e.g. 'Can you repeat that?'), feedback (e.g. 'You are great'), and conversational small talk (e.g. 'How are you?'). Since you are the owner of this solution, you can change the answers in these flows if you wish.

We will store our flows in a separate folder, so let's create that first.

1.  Make sure no existing folder is selected by clicking on your Solution root folder.
2.  Click the 'Folder' icon in the 'New' group located on the Ribbon bar.
3.  Give your folder a name, such as `Flows`, and hit __Enter__.

![1-flows folder](//videos.ctfassets.net/2vbtnveccz5s/JmHAyZ7cCLzvu2vwMq0bI/a3c3aa0cd02cad2b1e8a32a671b833ab/1-flows_folder.mp4)

!!! You can add as many folders and subfolders as you like and you can structure them any way you like. This is particularly handy for bots that handle multiple domains.

## Create your first flow

Now that we have a folder in which we can store our work, we can create our first flow:

1.  Select the folder in which you want to store your flow.
2.  Click the 'Flow' button in the 'New' group in the Ribbon. A new window will open (the flow window).
3.  Enter the name of the flow in the Name field, e.g. `User asks about coffees we offer`.
4.  Click on the left-pointing arrow in the top left corner of the window. This takes you to the main flow page.

![2-coffees we offer flow](//videos.ctfassets.net/2vbtnveccz5s/6RjhievHOL1QoJHZcGOVAW/0b8d56fe4da57d4b794492a50f564344/2-coffees_we_offer_flow.mp4)

As you can see, flows are represented graphically in Teneo. Simple flows just contain a trigger that recognizes the user's intent (the blue box labeled Trigger) and an output that contains the bot's answer (the purple box labeled Output). More complex flows contain more elements like multiple triggers, scripts, different outputs, etc. We're going to start with a simple flow, so you will only need to populate the trigger and the output that you see in the flow graph.

### Populate the trigger

Triggers are used to recognize inputs from the user that express a similar intent. In this trigger, we want to capture and understand the user's intent around which coffee Longberry Baristas serve. It is important to recognize that there can be several ways of expressing the same intent. For example, 'What coffee do you sell?' or 'Which coffees do you serve?'. To make the trigger match on user input, we need to add a [Match requirement](/studio/flows/concepts/triggers#match-requirements). This Match is essentially a criterion that needs to be met for an input to be matched.

1.  Select the trigger to open the trigger configuration panel.
2.  Give the trigger a name like: `Tell me about your coffee` by selecting 'Add name' on top of the trigger configuration panel.
3.  In the User Intent section, enter this example in the 'Enter an Example' field: `What kind of coffee do you have?`, then hit the 'plus' icon beside it or hit __Enter__. Alternatively, paste it straight into the Positive Intents section.

![3-populate trigger](//videos.ctfassets.net/2vbtnveccz5s/63Hv4qsVD4InNzwIB4hyen/9328d8424626e9a06d99bbbae2610e42/3-populate_trigger.mp4)

!!! You might have noticed the yellow 'TODO' label above the Match section. This means that the trigger does not contain a defined Match requirement yet. So, let's start with populating the trigger with example inputs and adding a Match.

Now, you can repeat the step above to add more examples one by one, but you can also paste multiple examples in one go:

1.  Copy the examples below:

```example-inputs
Do you have brewed coffee
Do you serve macchiato
Do you have cappuccino
Tell me about the coffees you have
Tell me about your coffee
What coffee do you serve?
What kinds of coffees do you serve?
What kinds of drinks do you sell
Which coffees are offered by Longberry Baristas?
Which drinks do you have?
Which sorts of coffees do you have
```

2.  Next, right-click the empty area in the learning example area and paste the inputs (alternatively, you can click the tab labeled 'Positive' and hit __Ctrl+V__ to paste them).
3.  Finally, add a Match. Click on the 'Generate' button under the 'Match' section. This will automatically generate a Match based on the example specification.

![4-populate trigger pt2](//videos.ctfassets.net/2vbtnveccz5s/4QEqzdOGJLqsCaQtI6cgvO/dfcd2434a4973d911253599596ae602b/4-populate_trigger_pt2.mp4)

When you generate a new Class Match, the Class gets generated based on the training data that you assigned for the User Intent. Once the Class is generated, it gets added to the overall machine learning model of your solution. However, if you want to expand your Class with additional training data, you have to do so in the [class manager](/getting-started/class-manager). You will learn more about the class manager on a later page.

!!! The positive examples are also used for auto-tests for when you want to [automatically test your bot](/article/build/test-your-bot/run-automated-tests).

### Add an answer text

Next, we will need to set the bot's answer in the flow. There are many options to define the bot's response. For now, we will focus on the answer text only.

1.  Select the purple box marked __Output__ (the Output node) to open the output configuration panel.
2.  Give the output a name like: `We offer a variety of handcrafted coffee drinks...`
3.  In the text box paste in the following: `We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.`

![5-populate output](//videos.ctfassets.net/2vbtnveccz5s/3K0tNPAkrhns9zBFR6ysST/175d1823260b49df0503de58d1f80538/5-populate_output.mp4)

## Save your flow

Now that we have added everything needed to our first flow, it's time to save it:

1.  Click 'Save' in the top left or use the shortcut __Ctrl+S__.
2.  In the popup that appears you can leave a short description that will appear in the flow's version history, then click 'Continue'.

![6-save](//videos.ctfassets.net/2vbtnveccz5s/7u0ZZw7v9duZm9qR3o2bwE/8271f291d35e4865fa422e79e96fcc80/6-save.mp4)

!!! Adding a description will help you remember the changes you did and will show up in the Flow's version history.

Done! Congratulations! You have created your first flow.

## Test your flow

Now it's time to test your work inside Teneo Studio.

1.  Minimize or close the flow you just created.
2.  If the Tryout panel is not visible, make it appear by clicking the 'Tryout' button on the right side of the window.
3.  In this case, you can test your flow by trying out the following examples:
*   `What kind of coffee do you have?`
*   `Which drinks do you serve?`

![7-tryout](//videos.ctfassets.net/2vbtnveccz5s/4nPUXLRFtejdwPh1h7DkJ1/42cc3d20fe37cbccbda906d181b9ed6d/7-tryout.mp4)

As you can see, both inputs will trigger your flow. Teneo not only recognizes the exact learning examples you entered but also different variations that express a similar intent.

## Summary

You have just created your first flow, so you have already seen a few important concepts in Teneo:

*   **Flows**, which contain the logic to resolve a specific question of the user.
*   **Folders**, where you can store your flows and language objects.
*   **Triggers**, to recognize the user input or intent.
*   **Match**, to set a criterion that the user input must match.
*   **Outputs**, to provide the bot's response.
*   **Tryout**, which you use to test your flows.

## Test yourself

Try adding another flow where the user can ask which coffee sizes are available at Longberry Baristas. The bot should return the three available sizes: **small**, **medium**, and **large**.

Your First Flow

Sometimes your bot will need some additional information from the user before it can provide a final answer. On this page, you will learn how to branch after an output prompt and take different paths depending on the user response. These paths in Teneo are known as transitions and are used to tie flow nodes together.

We'll use the following example, where the bot provides information about the coffee mug to the user, and then the bot needs a confirmation from the user before it proceeds to reserve a coffee mug:

> **User:** I want to buy a coffee mug.  
> **Bot:** The official Longberry Baristas coffee mug is only available for purchase in our store. Would you like me to reserve a mug for you?
> 
> **User:** Yes.  
> **Bot:** I have reserved a Longberry Baristas coffee mug for you.

or

> **User:** I want to buy a coffee mug.  
> **Bot:** The official Longberry Baristas coffee mug is only available for purchase in our store. Would you like me to reserve a mug for you?
> 
> **User:** No.  
> **Bot:** Ok, I will not reserve a coffee mug for you.

To achieve this we will do the following:

*   Create a new flow.
*   Populate a trigger with example inputs and generate a Match.
*   Add an output response in the form of a question.
*   Create a 'yes' transition if the user replies with 'yes'.
*   Add output response for the 'yes' scenario.
*   Create a 'no' transition if the user replies with 'no', and then add answer text for the 'no' scenario.
*   Save and test the flow.

This is what our flow will look like when it is completed:
![final flow](//images.ctfassets.net/2vbtnveccz5s/5oJ2Qu3UnIwkQT0b5qDi1L/1f2a149eb235aa367f318542968f0ce9/final_flow.png)

This page will only cover the communication with the user. To actually reserve a coffee mug, we would have to integrate with a service; we will leave that part out for now.

## Create the basic flow and populate the trigger

The first steps are to create a new flow and populate the trigger with relevant training examples. Start by doing the following: 

1.  Select the 'Flows' folder and create a new flow by pressing the 'Flow' button.
2.  Once the flow has been created a new window will open; enter the flow name `User wants to buy a coffee mug` into the name field.
3.  Press the back button in the top left corner and select the trigger to open the trigger configuration panel.
4.  Give the trigger the name `I want to buy a mug`
5.  Add the positive learning intents below either one by one, or paste them all at once by clicking where it says, 'No Positive Intents' and use the shortcut __Ctrl+V__ (alternatively, you can also right-click and choose __Paste__).

```example-inputs
Do you have branded mugs for sale?
Can I buy a mug please?
Do you sell mugs?
Can I purchase a mug?
Purchase coffee mug
I want to buy a mug
Do you have coffee mugs for sale?
I would like to purchase a coffee mug
I want to buy your coffee mug
Do you sell longberry barista mugs? 
I want to have a longberry barista branded mug
I want to buy a mug!
```
6.  Now we need to add a Match. Click on the 'Generate' button under 'Match' section, this will automatically generate the best Match requirement based on the User Intents.

![1-create flow](//videos.ctfassets.net/2vbtnveccz5s/12JcYdS5vLlN1pvVWk9gNt/235fdf6d9574dccecf5c563c6985f5a0/1-create_flow.mp4)

## Add answer texts to the output

Now we will populate the output node with answer texts. In this case, the output node will be used to give the user information about the Longberry Barista coffee mug and then ask a question, rather than just give a definitive answer.

1.  Select the output node to open the output configuration panel.
2.  Add an output name and enter a name like `Ask the user if they want to reserve a mug for in-store purchase`.
3.  Add the following answers to the output node (use the __Add__ button to add the individual answers):
*   `The official Longberry Baristas coffee mug is only available for purchase in our store. Would you like me to reserve a mug for you?`
*   `Right now you can only buy our coffee mug physically in our store. Do you want me to reserve one for you?`
*   `Our coffee mug is only available for purchase in our store. Shall I reserve one for you?`

![2-add output](//videos.ctfassets.net/2vbtnveccz5s/546idzGDSB86b5VtemLd2y/2220d8f3e90633e7b5a7a28336a0abd5/2-add_output.mp4)

Output nodes can contain multiple answer variations to make the conversation more dynamic. Teneo allows you to either randomly choose an answer and return it to the user, or to set order for the outputs to be returned.

```infobox
## A brief explanation of transitions

Before we start extending our flow with transitions, it might be a good idea to quickly go over the concept of transitions. Transitions link different flow nodes together and determine the paths a dialogue can follow within a flow.

By default, all transactions will create transitions that contain a User Intent. These transactions require the addition of one or more Matches. Transitions that have a User Intent but no assigned Match requirements will get a yellow 'TODO' label as a reminder. When the User Intent is enabled, the most recent user input must match the set Match to continue down the transition. You can remove the User Intent option for a transition. This means that the transition will allow any user input to continue down the transition as it has no Match requirements. Transitions are also ordered, which tells Teneo in which order to test the Match on conditional transitions.

Transitions are by default set to ‘Get input before continuing', which is also displayed in the flow graph. This means that the flow processing will stop and wait for the user to provide new input. If the user input fits the transition's Match requirement, the flow processing will resume along with the transition. If the transition is not set to wait for user input before continuing, the flow processing will not stop and wait for new user input. If this is the case, the most recent user input will be tested against the Match requirement.

![brief explanation](//images.ctfassets.net/2vbtnveccz5s/2xffTXp9v7XwzwqSBOFhC4/0cfe5efb4026b55a2e633b2bd52e954e/brief_explanation.png)

```

## Add two transitions

We have now reached the point in the flow where we expect the user is going to say either 'yes' or 'no'. Depending on what is said, the bot should react differently. Let us start with adding these transition.

1. Located under the output node 'Ask the user if they want to reserve a mug for in-store purchase', click on the Plus icon, followed up with 'Fork To' and 'Multiple complete transactions'.
You will now have the option to select the number of times the output should be forked.
2. Enter '2' and click on confirm.
Notice that two new paths are shown for the user to take. These will now be edited to cover the 'yes' and 'no' options.

!!! Do you see that there are numbers on the transitions (1 and 2 respectively)? These numbers represent the order in which Teneo will test the conditions. You can adjust this order by having the transition selected, then use the arrows found under the two checkboxes 'Get input before continuing' and 'Match' to increase or decrease the order of the selected transition.

So far, you have created two flows in your solution, each containing one trigger with a Class Match. But in the next section, you will get to add a Language Object-based Match to a transition.

![3-fork to transactions](//videos.ctfassets.net/2vbtnveccz5s/4kQ6tz3yEkGFx4rH9HpWWR/d06e156929e61a2cbffdd829e03ec381/3-fork_to_transactions.mp4)

### Add a Language Object Match

Now we need to make sure that one of the paths only matches (the line that connects two output nodes) when the user says ‘yes’. To achieve this, we need to add a new type of Match requirement, namely a [language condition](/studio/language-understanding/concepts/language-conditions). Simply put, language conditions check if a user input matches a certain pattern. They can be generated from a set of examples or you can specify them directly. Let's generate one from a set of example inputs.

1.  Open the transition configuration panel by selecting the transition labelled '1'.
2.  Give the transition the name `User says 'Yes'`. This increases the readability of the flow and makes debugging easier.
3.  In the examples panel, paste the following examples:
```example-inputs
Yes
Indeed
Yep
```
4.  Finally, click on the 'Generate' button under 'Match' section, this will automatically generate the best Match requirement based on the example specification.

After a few seconds, the match requirement field will get the value `(%YES.PHR)`. This is the 'Match' for 'Language Objects' that was generated. The language condition uses a 'language object' called YES.PHR, which recognizes various phrases (hence the suffix .PHR) that mean 'yes', like 'by all means', 'absolutely' and 'yup'. This perfectly covers our need for this transition. Note that there is a lot more you can do with language conditions, but that will be covered later.

The condition used as a Match in this example is based on the User Intents, and unlike class, there is no ‘condition manager’. This means that all conditions are managed on the node or transition itself.

![4-add LO match](//videos.ctfassets.net/2vbtnveccz5s/65neZaUFB4W7DdFbZwZ87P/16e288de66e63e4507a5f26a96296f31/4-add_LO_match.mp4)

So far, we have only added one Match per trigger and transition. We have only explored two different types of Matches, Class, and Language Objects. However, triggers and transitions can contain one or more match requirements. It is also possible to mix the Match requirement types depending on what the use-case requires, this is however not going to be covered on this page. You can read more about it [here](/studio/flows/concepts/triggers#match-requirements).

### Add an answer text

The last step to complete the 'yes' branch is to specify how your bot should respond when the user says 'yes'. The output node below the 'User says Yes' should be selected: 

1.  Give the output a descriptive name like: `I have reserved a coffee mug for you`.
2.  Finally, add the answer text: `I have reserved a Longberry Baristas coffee mug for you.`

![5-add yes path answer](//videos.ctfassets.net/2vbtnveccz5s/1AEnQtr3Rd7GrlZnsfDLfN/d864da46217be9c01708d3881e7cd8ad/5-add_yes_path_answer.mp4)

## Create the path for the user saying 'no'

Now, we will specify what should happen when the user says 'no'. We'll follow the same steps as when adding the first branch:

1.  Select the transition labelled '2'.
2.  Give the transition the name `User says 'No'`.
3.  Add a few example inputs in the examples panel:
```example-inputs
No
Never
Nope
```
4. Finally, click on the 'Generate' button under 'Match' section, this will automatically generate the best Match requirement based on the example specification.

![6-add no path](//videos.ctfassets.net/2vbtnveccz5s/12LaZKGhZEpqauGIoPP2oM/cb91669d681e2af1aa988e56071cf423/6-add_no_path.mp4)

### Add an answer text for 'no'

Almost there! Now we need to make sure that the reply is recognized and taken care by the flow.

1. Select the Output node below the transition.
2. Give it the name: `Ok, I will not reserve a coffee mug for you`.
3. We can reuse the name of the output node as our answer text.

Finally, save your flow by clicking 'Save' in the top left or use the shortcut __Ctrl+S__.  

![7-add no answer](//videos.ctfassets.net/2vbtnveccz5s/6j4kKdhktZdfWaU3Ghoo1y/868d4bc77f622d7bed92e6d71c938675/7-add_no_answer.mp4)

## Try it out!

That's it! If you would like to test the flow from within Studio, minimize or close the flow, if the 'Tryout' window is not open, you can reopen it panel in the 'Solutions' window and have a go.  

![8-tryout](//videos.ctfassets.net/2vbtnveccz5s/2X7NmxRSRwI3RxbCH7XYg6/b295ebc28b43958dd92ac6af2a7e7d43/8-tryout.mp4)

!!! Notice the __Flow Updated message?__ The Tryout panel is also used for the bot to communicate with you. When something is updated or wrong the Tryout will print a message for you.

## Summary

You've just created your first interactive flow and used the following components:

*   **Match**, which are used to set criteria that the user's input must match.
*   **Multiple answer variation**, used to make the bot's responses more dynamic.
*   **Language condition**, which you can use to ensure that the user input matches a certain pattern.
*   **Transitions**, which determine the path your dialogue should take.

## Test yourself

Try to add one more branch, but this time for if the user answers with an answer that does not meet the match requirements of the __Yes__ or __No__ transitions. Make sure to test your flow in Tryout!


Transitions

Teneo offers a wide range of Match requirements to add to your trigger. One of them is the Machine Learning-based Class. We know from the previous page, [Your First Flow](/getting-started/your-first-flow#populate-the-trigger), how to generate a Class while working on a flow. This chapter will be about maintaining these classes.

Located in the ribbon bar is the 'Class Manager'. Clicking it will open the Class Manager in a new window that looks like this:

![class manager window](//images.ctfassets.net/2vbtnveccz5s/jlZmiyU0gRw9LCmnlEdPG/540f2e35c24c6349fcd2429929b572f9/class_manager_window.png)

The left section of the Class Manager is a list of the classes inside the solution. Selecting one will let the user see the training and test examples. To the left of that, the user can also see which flows the class is being 'Used by' and which test examples can be found in those flows.

!!! It's important to acknowledge that the training data is inside the Class Manager; changing it will fully affect the flow using the class, and it is only possible to change it from the Class Manager. The test data, however, can be changed from either the flow or the Class Manager.

## Add a training example

If we select the 'TELL_ME_ABOUT_YOUR_COFFEE' class, we can see that the solution doesn't have training data for the coffee type 'Cortado', even though it is a popular coffee type.  

If we want to add this coffee type inside the Class we'll need to do the following.

1.  Open the 'Class Manager' and select 'TELL_ME_ABOUT_YOUR_COFFEE' class.
2.  Click on 'Edit' in the ribbon bar and add the training data `Do you serve Cortado`.
3.  Hit 'Save'.

Now you'll see the before and after we added training data for the coffee type 'Cortado'.  

![1-add training example](//videos.ctfassets.net/2vbtnveccz5s/6rNYDrWQFZhGK0ewEihvZQ/12f41d3fdcbcab52e582d37e9276afad/1-add_training_example.mp4)

!!! When you go back to the Tryout window you'll see a small text saying, 'Model training in progress', this indicates that the changes you've made are saved and the platform is currently re-training the classes in the machine learning model. This will change to 'Model update completed' when it's done.

## Add a test example
It is important to note that training examples can only be added from the Class Manager page once the Class has been created. It is not possible to add training examples from the flow editor page. This will only add 'Test Data' that will be used when [testing your bot](/article/build/test-your-bot/run-automated-tests) and not 'Training Data'.

![test data](//images.ctfassets.net/2vbtnveccz5s/5PAuwRoyGe3pnDR3NjTXsA/0d31b3b9621bf4894f910a957f29c2f1/test_data.png)

Test data can also be viewed and added in the Class Manager itself. Let's try that now.

1.  Open the 'Class Manager' and select the 'TELL_ME_ABOUT_YOUR_COFFEE' class.
2.  Click on 'Edit' in the ribbon bar and click on the 'Test Examples' tab.
3.  Add the test data `Do you serve espresso?`.
4.  Hit 'Save'.

![class-manager-test](//videos.ctfassets.net/2vbtnveccz5s/46kMR0JlMSI8lO3djrATQD/3a47c87f1db9841805e8900489f2bb3d/class-manager-test.mp4)

## Generate examples
Teneo's copilot features allow you to quickly generate new training and test examples with the help of Generative AI. These can be generated based on existing examples or based on the class description.

!!! In order to enable copilot features, make sure to first [define settings to use Generative AI](/documentation/latest/home/teneo-7.4/teneo-studio#teneo-studio_generative-ai_studio-account-page).

### Training examples
Let's generate some training examples based on existing examples.
1. Open the Class Manager and select the 'TELL_ME_ABOUT_YOUR_COFFEE' class.
2. Click on 'Edit', followed by the 'Generate' button.
4. Select whether you want to generate examples based on existing examples or based on the description, and how many examples you'd like to generate.
5. Click on 'Generate' and 'Yes' when ready to generate.

The new examples should appear with a yellow highlighting line to distinguish them from previously existing examples.

![generate training examples](//videos.ctfassets.net/2vbtnveccz5s/2X6hY0tcq71zfxqDzJi6yo/6af8d2ffb2ba4baabb7edc49cf4a4257/generate_training_examples.mp4)

### Test examples
Just like training examples, test examples can be generated either based on existing examples or a description. Let's try the latter approach this time.

1. While still in Edit mode, switch to the Test examples tab.
2. Click on the Generate button and select the option to generate based on a description.
3. Enter a description, such as `The user asks questions about which types of coffee you serve`.
4. Click on 'Generate' and 'Yes'.

Just as before, the newly generated examples are marked with a yellow highlighting.

![generate test examples](//videos.ctfassets.net/2vbtnveccz5s/39OCSRl57rxw5mbwcOYxXv/96ba147aa0a95e3a5c8c959f26e55e4b/generate_test_examples.mp4)

Class Manager

Teneo comes with a collection of pre-built [Entities](/studio/flows/concepts/entities/) that you may use in your flows. However, sometimes we need to create custom entities for our bot. This is the case for the different kinds of coffee types that are served at Longberry Baristas. In the following section, we will walk you through the creation of this custom entity.

## Create an 'Language Objects' folder

Before we create our entities, it might be a good idea to create a folder that we can use to store them. This is not required, but as a solution grows, folders help to structure your Teneo assets. To create the folder, proceed as follows:

1. While in the main solution view, make sure the solution root folder in the Explore section is selected.
2. Click on the Folder icon in the ribbon bar to create a new folder.
3. Give the folder a name, such as `Language Objects`, either by double clicking the name or clicking on the Rename icon in the ribbon bar.

![1-LO folder](//videos.ctfassets.net/2vbtnveccz5s/2yLhb5iUTOkDhEcSNk8H3K/5f8219f11af8a5c5c6f05e2c5564af55/1-LO_folder.mp4)

## Create a 'Coffees served' entity

Let's create the entity for recognizing the different kinds of coffees that are served at Longberry baristas. In Teneo, an entity can either contain words, phrases or [language objects](/studio/language-understanding/concepts/language-objects). Generally speaking, language objects are usually lists of synonyms or thematically related words, which are used to recognize the wide variety of user inputs. This means that language objects ensure a broader coverage, including the plural forms, declinations, and synonyms of the words compared to just using words or phrases. In other words, we do not have to specify every form or synonym of a word to get great coverage. For example, the language object '%AMERICANO.NN.LEX' will not only recognize "Americano", but also the plural form "Americanos". 

The entity that we are creating in this section will contain both language objects and words like brewed coffee (singular) and brewed coffees (plural). Since no language object covers the different forms of ‘brewed coffee’ we have to specify them ourselves in the entity. It would be a good idea to create a language object that covers both singular and plural forms of ‘brewed coffee’, and then use that language object as an entry in the entity instead. However, we will skip this step for now... 

This is how we will go about it:

1. Make sure the newly created 'Language Objects' folder is selected.
2. Click on the Entity icon in the ribbon bar.
3. A new window will open. Name the entity `COFFEES_SERVED` (the type .ENTITY is automatically defined).
4. Click on the back arrow to go to the Home tab of the Entity, where you will be able to edit it.
5. Copy the following table onto the clipboard:

```table
|  Coffee name  |  coffeeType  |
|  :-----          |  :-----          | 
|  %AMERICANO.NN.LEX|  americano | 
|  %CAPPUCCINO.NN.LEX|  cappuccino | 
|  %CORTADO.NN.LEX|  cortado | 
|  %ESPRESSO.NN.LEX|  espresso |  
|  %FRAPPUCCINO.NN.LEX|  frappuccino |  
|  %LATTE.NN.LEX|  latte |  
|  %LUNGO.NN.LEX|  lungo | 
|  %MACCHIATO.NN.LEX|  macchiato |  
|  %RISTRETTO.NN.LEX|  ristretto | 
|  flat white|  flat white |  
|  flat whites |  flat white |  
|  brewed coffee|  brewed coffee |  
|  brewed coffees|  brewed coffee |      
|  filtered coffee|  brewed coffee |  
|  filtered coffees|  brewed coffee |
```

!!! Note that filter coffee and brewed coffee are considered synonyms and both should return the type 'brewed coffee'.  

6. Inside the Entity, select the cell marked 'Click here to add a new entry'.
7. Paste the table you copied earlier.  
8. You will now be prompted to say whether the data you pasted includes a row of headers or consists purely of data. In our case, the first row consists of headers, so select 'First row is variable names'.
9. Hit 'Save'.

As you can see the entity structure is similar to a spreadsheet as it contains columns and rows. The left column contains entry values like language objects and words. In the right column, we have the variable 'coffeeType' which contains the string value of the entry on the corresponding row. For example, if we recognize 'americano' the variable 'coffeeType' would get the value "americano". You will learn more about how to extract data from user input on the next page. 

!!! The language objects used in the entity above are of the type [lexical entries](/studio/language-understanding/concepts/language-objects#names-and-types-of-language-objects), which are the smallest building blocks from which more complex language objects can be built. All language objects have a suffix that denotes which type it is. On this page, we have worked with lexical entries which have the suffix ‘.LEX’. Language objects of the type lexical entries usually contain different inflections, regional variations, and spelling of a word.

![2-add coffees served entity](//videos.ctfassets.net/2vbtnveccz5s/5YsdU4tEpP0IBDuPeVcxRE/a5c422eca8655c12f48c1736c3c2f195/2-add_coffees_served_entity.mp4)

## Generate Entity entries
Teneo's copilot features allow you to quickly generate more entries for entities. Let's try that now to expand the entity.

!!! In order to enable copilot features, make sure to first [define settings to use Generative AI](/documentation/latest/home/teneo-7.4/teneo-studio#teneo-studio_generative-ai_studio-account-page).

1. Click on 'Generate Entry'.

As we already have existing entries, let's generate more based on those. If you prefer, you could also generate entries based on a description which you would need to enter at this step.

2. Select the number of entries you wish to generate and click on 'Generate', followed by 'Yes'.

The newly generated entries will be distinguished from the old ones with yellow highlighting.

![generate entity entries](//videos.ctfassets.net/2vbtnveccz5s/27Vhp3OT4VR55FKAjh0ig9/c4cef3cb1e34bf80d8cffde1f88dba4c/generate_entity_entries.mp4)

Make sure to evaluate the generated entries. If generating Language Objects, you may need to create the referenced Language Object for the entity entry to be valid. For example, let's add one for the invalid Language Object reference to `AFFOGATO.NN.LEX`:

1. Navigate to Language Objects and add a new Language Object.
2. Give it the name `AFFOGATO.NN.LEX`.
3. Add the TLML Syntax `affogato`.
4. Hit 'Save'.

Repeat the process for other invalid LO references, `COFFEES_SERVED.ENTITY` and populate the string variable column 'coffeeType'. Your entity should now look something like this:

![finished entity](//images.ctfassets.net/2vbtnveccz5s/3Rp0b8M9D1475RccYo6LJX/f44e304f68a9cd88d3b8e387d12a3ea5/finished_entity.png)

## Summary

Great job! You have just created your first custom entity and worked with these components:

* **Folder**: Helps you keep your solution organized,
* **Entity**: A way of structuring data and mapping entry values to variables that can be used for data extraction,
* **Language objects**: Used to get broader coverage for plural forms, declinations, and synonyms of words so the bot can recognize a wide variety of user input.

```infobox
## Test yourself
We have now successfully added an entity that stores coffee types. Next, have a go at adding another entity by yourself. This time, make a new entity to hold the following coffee sizes:

|  Coffee size  |  coffeeSize  |
|  :-----          |  :-----          |
| small |  small |
| medium |  medium |
| regular | medium |
| large |  large |
| big |  large |
|  supersize |  large |
| venti | large |

```

Introduction to Entities

Entities

Sometimes it's not enough to recognize which flow to trigger. Your bot may also need to extract some piece of information from the input to respond appropriately.  

A typical use case is, picking up the user's order and repeating it, like in this example:

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: A espresso, please.  
> **Bot**: Ok, a espresso will be ready for pickup in 5 minutes.

In the following, we will show you how to create a flow that enables users to have this kind of conversation with your bot. This approach will make use of the entity we [created earlier](article/getting-started/create-custom-entities). These are the steps involved:

*   Add a new flow.
*   Set up a flow variable.
*   Add another output node.
*   Configure an After Match to extract information.
*   Use the information in the output.

![final flow](//images.ctfassets.net/2vbtnveccz5s/65MkL1Az1238dwIFsh7NWj/3ceaf3f28bc416d33d4f13c9c29a3247/final_flow.png)

## Create a new flow

We begin by creating a new flow. Just as previous flows we have built, it will have a trigger and an output node.

1. Create a new flow and call it `User wants to order a coffee`.

#### Populate the trigger

1.  Name the trigger `Order a Coffee`.

Now it is time to populate the trigger:  

2. Copy the following learning examples to your clipboard:
```example-inputs
A small filter coffee, please
Can I get a coffee?
Can I have a coffee, please?
Can I order a coffee
Can I order an espresso?
Can you get me a coffee
Could I get a large macchiato?
Could I have a flat white
Could I order a large americano
Give me a Frappuccino, please
I want a small cappuccino!
I want espresso
I want to order a coffee
I would like a coffee
I would like to order a coffee
I'd like a large espresso
I'd like to order an americano
May I have a filter coffee?
```
3.  Select the trigger, go to the 'Examples' panel on the right, and click where it says 'No Positive Examples'. Then hit __Ctrl + V__ to paste the learning examples. You can see that it worked when the examples appear in the field. Have a look at the video below if you are unsure how to import all examples at once.
4.  Scroll down to the Match section and select the 'Generate' button, this will automatically generate a class trigger.
5.  Your trigger is now configured.

![1-create flow](//videos.ctfassets.net/2vbtnveccz5s/2OfDMqLolMwBhHc4MklNr/0912e02ec8bd51e196a8fa163608fd07/1-create_flow.mp4)

#### Populate the output node

In the output node, we want to prompt the user to indicate the desired coffee type in more detail:

1.  Select the output node.
2.  Name the node `Ask for coffee type`.
3.  Go to the 'Answer' panel and paste the following: `Ok, what coffee would you like?`.

![2-populate output](//videos.ctfassets.net/2vbtnveccz5s/4CfuRFpttaW4W3HEtqKSo5/682981595731b7873027b369ef802369/2-populate_output.mp4)

## Extract information from the user input

So far so good. You now have a flow that triggers when users want to order a coffee and it answers with a question about the coffee type. To be able to pick up the coffee type from the user input, we now need to proceed with the following:

*   Set up a flow variable to store the coffee type.
*   Add an additional output node that will summarize the order including the coffee type.
*   Extract the coffee type on the transition between the two output nodes using an After Match.

### Create a flow variable

The flow variable we create here will later hold the coffee type that the user has mentioned:

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

![3-add flow var](//videos.ctfassets.net/2vbtnveccz5s/1zBbRXBm7mIAspORpOIRvY/4abed8d48ac27d725ac87a500382441a/3-add_flow_var.mp4)

### Add an additional output node

The transition between the two output nodes should only be traversed if the user mentions a coffee type. To ensure that, we need to:

1. Click on the Plus icon below the output node, followed up with 'Continue With' and 'Transaction'.
2. Name the transition `User responds with coffee type`.
3. With the transition selected, go to the Match section and click 'Add' and then 'Entity' from the drop-down menu.
4. Enter `COFFEES_SERVED` in the Entity field. This means that Teneo will only continue when the user mentions something which matches the entity.

![4-add additional output](//videos.ctfassets.net/2vbtnveccz5s/2rubKShdYqWDORo2dgY3RP/808221aa142a5e4ba786a4e8986f70d8/4-add_additional_output.mp4)

### Extract information from the entity
We will store the coffee type that the user has mentioned in the flow variable `orderedCoffeeType`, and we will do so using an After Match:

1.  Make sure the `User responds with coffee type` transition is still selected.
2.  In the configuration panel, go to the After Match section, click 'Add', and select 'COFFEES_SERVED' under 'Entity'.
3.  Now click into the 'Entity' field, which will make the 'Add Mapping' button clickable. Click the 'Add Mapping' button.
4.  The first field is the 'Source' field. This denotes the value of the NLU variable of the entity 'COFFEES_SERVED' that we want to store. Select `coffeeType` from the dropdown menu.
5.  The second field is the 'Target' field. This denotes the name of the variable where the extracted value is to be stored. Select `orderedCoffeeType` from the dropdown menu.

![5-extract entity](//videos.ctfassets.net/2vbtnveccz5s/E8oU9zF5ngmdxNaEitqrE/49a80c77d948ad07e9b6df7430427688/5-extract_entity.mp4)

### Configure the output

Finally, now it's time to edit the output node which will hold the summary of the user's order. Note that we add the newly created variable `orderedCoffeeType` First we have to:

1. Select the output below the transition.
2. Name this output node `Summarize order`.
3. Select the 'Answer' field of the new output node and paste `Ok, a ${orderedCoffeeType} will be ready for pickup in 5 minutes.`.
4. Save the flow and you're done!

![6-output and save](//videos.ctfassets.net/2vbtnveccz5s/48Rzs2vh0xVdWJ6vbneenD/c95f68be0b4c5e0aeecab4eb29bf224e/6-output_and_save.mp4)

## Test the scenarios

Now it's time to test the flow!

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: A cappuccino, please.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

![7-tryout](//videos.ctfassets.net/2vbtnveccz5s/5gX1rUKp9FdP1sM1WCe5fd/f48490c911344ea9e8935c8222d793e6/7-tryout.mp4)

## Test yourself

If you have done the previous [test yourself](/getting-started/create-custom-entities#test-yourself) there should be a working entity for Coffee Sizes. Add that entity here and don't forget to try it in Tryout.

Extract Entities

Sometimes the user tells you the answer to certain questions earlier than expected. It is important to be prepared for these instances by combining the use of 'After Match' and 'Skip Conditions'. This combination will allow the flow to extract information with 'After Match' and skip the questions we already know the answers to with 'Skip Conditions'.

Before adding 'Skip Conditions':

> **User**: I'd like to order a Cappuccino  
> **Bot**: Ok, what coffee would you like?  
> **User**: I already told you, a Cappuccino!  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

After adding 'Skip Conditions':

> **User**: I'd like to order a Cappuccino.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

## Extract entities from the first input

The current stage of the 'User wants to order a coffee' flow doesn't extract the entity if you mention a coffee type in the first input. To do that we need to add another data action on entities but this time for the trigger:

1.  Open 'User wants to order a coffee' in edit mode.
2.  Select the 'Order a coffee' trigger node, this will open a trigger configuration panel.
3.  Scroll down to the 'After Match' section and click on 'Add' followed up with 'Entity' to extract values from our previously created [entity](/getting-started/create-custom-entities#create-a-coffees-served-entity).
4. Paste in `COFFEES_SERVED`.
5. Click on 'Add Mapping' below the entity name.
6. Now use the drop-down menu below to determine the source __coffeeType__ and the target __orderedCoffeeType__. This transfers the value from the source and assigns it to the target.

![1-extract entities from first input](//videos.ctfassets.net/2vbtnveccz5s/35QhoqW2v9DIWsidWJ3ssy/e0e82b997126d6fe325174fd9ea02f04/1-extract_entities_from_first_input.mp4)

## Specify when outputs should be skipped

Now it's time to specify when output should be skipped:

1. Select the 'Ask for coffee type' node to open the output configuration panel to the right.
2. In the middle of the output configuration panel, you will find the 'Skip Conditions' field. Click on 'Add' to create a skip condition.
3. Paste `orderedCoffeeType` into the 'Skip Conditions' field. This will be evaluated to true if the variable is set and to false if the variable is empty.
4. Now use the drop-down menu beside 'Skip to' to determine how the flow processing should go on. In this case it should be 'User responds with coffee type'.
5. Hit 'Save'.

What we have done here is to tell Teneo: if the __orderedCoffeeType__ has a value when you reach the 'Ask for coffee type' output node, *skip it* and traverse the path 'User responds with coffee type' without waiting for an input from the user.

![2-add skip condition](//videos.ctfassets.net/2vbtnveccz5s/4sDOWMQbvexZ4QT5twABdt/12575ebd6f8437f74783c727b4c56de8/2-add_skip_condition.mp4)

## Test the scenarios

Now it's time to test the flow!

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: A cappuccino, please.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

It is now possible to put all details into one single request:

> **User**: I'd like to order a cappuccino.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.


Adapt to user input

Skip Conditions

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 change the [coffee order flow](/getting-started/build-a-slot-filling-flow#create-a-basic-flow) so that it may be interrupted and then resumed if the user doesn't immediately respond 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:

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

## Set the output node to 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'. Select it and set the limit to 2. This limits how many interruptions in a row the output node should survive. Note that the border around the node in the graph disappears! This signals that the node is now revisitable.

![1-revisitable](//videos.ctfassets.net/2vbtnveccz5s/6BANts7U1QKAUQDzSwp1ge/75c145201defc01ce436115b51a5dd25/1-revisitable.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 adjusted flow 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

Quite often users will ask a follow-up question to an answer your bot just gave, like so:

> **User:** I want to order one espresso  
> **Bot:** Ok, a espresso will be ready for pickup in 5 minutes.
> 
> **User:** I'd like one more *(follow-up)*  
> **Bot:** Ok, what coffee would you like?
> 
> **User:** Flat white this time  
> **Bot:** Ok, a Flat white will be ready for pickup in 5 minutes.

As you can see in the example dialogue above, follow-ups are quite often very generic inputs that can have different meanings depending on the context of the conversation. In the example above, the user wants to order another cup of coffee; however, in a different context, the user might have meant to place the same order again, for example.

There are different ways to manage dialog context in Teneo. We will now explain one way: dealing with inputs that can be considered direct follow-ups to the same flow. We are going to implement the example dialog above by adding a context-dependent trigger to the [coffee order flow](/getting-started/build-a-slot-filling-flow#create-a-basic-flow) flow that we created earlier.

What we will do is the following:

*   Add a second trigger to our flow.
*   Make the trigger context dependent using the Match for Context, Follow up of Flow.

The final result will look like this:

![flow layout](//images.ctfassets.net/2vbtnveccz5s/5amcqL6xPmAke9bG6vpWyG/afb63401bffe6dcbda4eee3a1e9ed4d3/flow_layout.PNG)

Let's get started!

## Add a second trigger to the flow

Go ahead and add a second trigger to handle the follow up questions:

1. Open the flow 'User wants to order a coffee' in edit mode.
2. Click on the Plus icon next to the existing trigger, followed by Add Trigger.
3. Give the trigger the name `Another one please`.
4. Add Intent examples to the newly created flow trigger:  
```example-inputs
Another one
Can I order another one
One more
Can I make one more order
Another order
1 more
```
5. Generate a Match by pressing 'Generate' on the Match section. This will create a Class Match.

![1-new trigger](//videos.ctfassets.net/2vbtnveccz5s/17zsQk22SpnloL1gNDS1ny/9bc09587e6191561504b02dec78695ed/1-new_trigger.mp4)

## Make the trigger context dependent

We are going to context restrict the second trigger 'Another one please' so it only fires if the same flow has just been active. To achieve this we are going to use a global scripted context which uses a script to evaluate if a context is true.

1. Select the 'Another One' trigger to open the configuration panel.
2. Scroll down to the Match section and 'Add' a new 'Scripted Context'.
3. From the dropdown, choose the global context 'Follow up of Flow'.
4. Make sure the value chosen is __sameFlow__ (it will be chosen by default).

![2-add context](//videos.ctfassets.net/2vbtnveccz5s/1aSoXKXwpvi8pqJD38bFlk/bc3066a6db3d47dc82c36039c9dc287d/2-add_context.mp4)

!!! The global scripted context 'Follow up of Flow' only evaluates to true if the context restricted trigger exists in the same flow as the previously fired flow. For more details, see: [Predefined context restrictions](/studio/conversations/concepts/context#predefined-context-restrictions).

## Save and test your flow

That's it! Now you can save the flow and give it a try in the Tryout window.

First try a working case:

> **User:** I want to order one espresso  
> **Bot:** Ok, a espresso will be ready for pickup in 5 minutes.
> 
> **User:** I'd like one more *(follow-up)*  
> **Bot:** Ok, what coffee would you like?
> 
> **User:** Flat white this time  
> **Bot:** Ok, a flat white will be ready for pickup in 5 minutes.

Now restart your Tryout session by clicking the 'restart' button, this will start a clean session without any dialog history. Then try the following input that you would normally use as follow-up, but this time without any preceding question:

> **User:** I'd like one more.  
> **Bot:** I'm sorry but I didn't get that.

![3-tryout](//videos.ctfassets.net/2vbtnveccz5s/sSoakfHZU2fi1sq8R0vzo/5ff8a9844d64b1558eb0763d4e52a1e5/3-tryout.mp4)

Getting started

Add a second trigger to the flow

Make the trigger context dependent

Save and test your flow

Next page