Hey there everyone, Jonathan Sylvia here from Pragmatic Works. Welcome to Autonomous Agents in Copilot Studio. For

our session here today, what we're going to really look at is how we can set up our very own autonomous agent, a little

bit of like an AI personal assistant for us utilizing Code Pilot Studio. Now, this is pretty new, so some of you may

not have every last piece of everything we're going to be working with, or it's now just come available to you. So, I

really encourage you to try to follow along if possible. Otherwise, you can just watch, learn, and try to see how

you can utilize this for yourself in the future. So, starting off with here today, let's take a look at what is an

autonomous agent and what are the differences between the types of agents we have within Copilot Studio. Now, here

in Copilot Studio, some of the types that we have, some of the classic types of of agents really, you're starting

with our retrieval. That's just your general chatbot, if you will. You ask it questions, it returns you information.

So, you're taking that information from data, from web pages, from knowledge sources that you're adding into your

agent. Now, as you start to go from that classic chatbot retrieval, ask and get qu uh ask questions, get answers, what

we can then do is start to get a little bit more complex and a little bit more autonomous along the way. So kind of the

middle stage that we have is this task oriented agent that we can develop for that agent. We can ask it to complete

things for us as again kind of like a personalized assistant where we can utilize power automate workflows and we

can have it go ahead and continue to do things on demand as we prompt it within the agent itself. Traditionally we build

that in Copilot Studio by adding in specific topics. Once a topic is triggered, we go down the path within

that conversation and then we can go ahead inside of that topic and complete those tasks. Now, today what we're going

to focus on is the most complex version of this and that's making an agent that it's 100% autonomous, meaning that it

operates independently. So it will look dynamically at what we instruct it to do and then it will go ahead and decide how

to complete a process, a task or whatever we we tell it we want it to complete for us. One of the nice things

about this is we can have agentto agent handoff. We can have escalation. We can have our agent learn from its past so

that we can make sure that everything that we want accomplished is going to be done by that agent. And we could put a

lot of guard rails on that as well to make sure it's the exact right answer or operation or task whatever it may be

each and every single time. Now here are some of the spectrums of the three different really types of

agents that we have with co-pilot studio. Now again starting with your more simple your more retrieval style of

agent moving into that more advanced as we jump past kind of the the task orientation. So like a very simple agent

that we have with Copilot Studio is something like an IT help desk where we just simply ask questions again within

the chat experience. How do I connect to the network or what are the office hours or where's my printer? Something along

those lines. I ask a question, we get an answer from the agent itself. We can also do like a project tracker where

it's looking up data, retrieving information from the data itself. So it's based in that data whether it's in

data versse or excel or uh sharepoint or wherever that data may live SQL we can go ahead and grab that information for

us. Now the more task oriented again are going to be more of like let's do something with this agent. So our device

refresh we can get a request new laptop maybe we embed an adaptive card into our agent conversation and we can fill out

all the information using that adaptive card in the chat and then pass that in. go ahead and and put in that request and

store it say on a SharePoint list or uh Service Now or wherever we want that to be uh kept. We can do our expense

reporting in here. Again, you're just reviewing the expense reporting um and all the different open purchase orders

as you can see here and and try to get that information back. Like it's going to go to the data, retrieve information,

help us accomplish a task. As we get more into the autonomous and the more advanced side of the path here, that's

where you can see things like our lead generator where it's identifying these things automatically for us and then

giving us that maybe an email or a message or some type offormational uh piece that we can then review and use

for ourselves moving forward. And of course, we have that customer support which a lot of us really want is to be

able to automatically identify issues and then pass that off to multiple different agents in order for them to

handle that scenario based on the issue that you know pops up for us. So you have a lot of variety in the types of

agents that we can develop and really it depends on the scenario that you have. And one of the nice factors is we can

have the multi- aents now. So we can have one kind of agent hub for us that passes off to other agents depending

upon the task. So you can really incorporate your advanced autonomous agent with some of those more you know

task or retrieval t uh style of agents as we go forward from there. Now specifically talking about autonomous

agents that we have here today. One of the really nice things about this is we can dynamically reason over its

capabilities and kind of learn about itself and learn from itself on how to fix and how to solve problems in the

future. We can continue to have those human guard rails in there and you can have it ask for help or need more

assistance or you know return something like I'm not sure about that let me you know please rephrase it or something

along those lines that we can have there. And of course that orchestration between other agents is something that's

so very nice to be able to utilize to be able to pass off to more of those task oriented style agents. Go ahead and

accomplish this once that um trigger occurs or when something else happens. So that leads us into the beginning

stages here for our learn with the nerds workshop where we are going to go ahead and build our custom agent from scratch.

We're going to start off with really only focusing on the autonomous part of things. We're going to talk about

triggers or talk about tools and passing off to other agents and getting everything ready for that. However, it

is also really important to go ahead and explain our scenario and what kind of data we're working with. So, we're going

to start off with that piece to get all that organized and then we'll build our agent and all the parts that follow from

there. So, if you take a look at our course materials here for this session, what we have within there is a a

downloadable file. I've gone ahead and put that into my one drive to be able to utilize here for my agent to use and to

also build out here today. So, I'm going to go ahead and open up my one drive and access all the information in that

folder. So, I'm going to go ahead and move over to one drive real quick. Here we are. And you can see here I have all

these different files. We are going to start off with our Microsoft form template. There's a PDF here. If you

open it up, all we'll need to do is copy out the link that's inside of that, which is right here. If you want to

select that link, right, we want to take that and we want to open that here in Microsoft Forms. Once you have it opened

in Microsoft Forms, all I did was clicked on it there. We can go ahead and select duplicate it at the top. That's

going to go ahead and set up your very own copy of this form so that you can use the exact same one that I'm using

here if you so chose. All right, selecting duplicated on that. All right, there you go. It's finished

loading there and it's saved for me. Now, the name of this form is our Pragmatic Works landscaping request. It

does say the word copy in that. So, if you want to go ahead and remove copy, just going to click on the title there

and you can go ahead and remove it there. All right. And just click away and it gets saved. Now, this form kind

of explains the entire scenario. So, we're going to have this fictitious company called the Pragmatic Works uh

landscaping solutions company that's just going around the area here in Jacksonville, Florida. Um, you know,

working on landscaping. So, it's residential, it could be commercial, it could be just simple lawnmowing or other

things that come with landscaping services that we may offer. This form is going to allow us to have other users,

external users, come in and put in a request for information or for services if they so choose. So all the user will

need to do is come in here and answer the questions. We have a field for name, field for email, zip code, interested

service, project description, and just your general how did you hear about the hear about us. When the user fills this

out, what we want is our autonomous agent to go ahead and take that information and automatically figure out

which one of our employees, our technicians or salespeople, whomever it may be, we should assign this request

to. That's the big goal. So, when somebody comes in here and submits this form, we want to automatically have our

agent determine which employee we want to assign it to. So, now we have to think, okay, well, how do we know where

that information is coming from? How do we know exactly um which employee to pull? Well, if you go back to our little

one drive folder here, I'm going to go click out of this preview there. What we have here are two Excel files. The one

that we're going to start with is this employee information file. If I open it up here,

all right, I have just a very very basic table here in Excel. On this table, we have an employee ID column, an employee

name column. Some of the trainers here at Pragmatic Works. We have an employee email column. I'm just passing in my

dummy email address here that I'm going to utilize for today. So, if you want to go ahead and test this out for yourself,

go ahead and just put your email address there and you could see if exactly does the right uh work there. In reality,

this email address would of course match up to that employee. We're not going to be doing that. I don't think they want

to hear all or get all these emails from me today. So, I'm just going to use this email address. We also have a zip code

that that's essentially their territory and the areas that they cover. So, I included the cities that go with those

zip codes. So, in this case, kind of the general the bigger city for that. All of these are in the St. uh sorry the the

Jacksonville, Florida area there, including St. Augustine as I was getting to. Um and so that's really what we're

going to focus on is really going to take our zip code here when the requester comes in, fills out the form.

Once they fill out the form, we're really going to focus on mostly the zip code, but we could do it on any other

field as well. And then use the zip code essentially as a lookup. find out which employee is covering that area based

upon that. That's how we make our assignment. That's really what we want our agent to be able to handle all by

itself. So there's our data to work with. We have our form ready to go. In fact, if we actually want to use the

form, all you'll need to do here is select the preview button at the top here within Microsoft Forms. Once I do

that, I can actually, you know, fill it out and submit it. So there's your quick answer to that. All right. So, we have

all of that prepped, ready to go. All we need is that agent to handle it for us. So, let's go build out our agent. Now,

the way we're going to do that is we are going to, of course, use co-pilot studio. So, if you go ahead and navigate

over to copilotstudio.microsoft.com, you'll get in there. You can also do the preview.microsoft.com

as the one you can see that I'm currently using. That's just going to enable any of the preview features that

do come out within Copilot Studio. You'll see them available here. so long as that's been turned on by your tenant

admin. Now, what we also have here when we build out our agent is we can go ahead and utilize Copilot to help us

build our agent or we can simply come over here to the create area and build from scratch. And that's what I'm going

to do here today. Just go ahead and build everything from scratch from the beginning because I just really want to

focus on the autonomous part of things. If you want to be able to see all the other features within Co-Pilot Studio, I

absolutely encourage you to take a look at some of our YouTube videos or the courses that we have either by myself or

by Amelia Roberts. You'll see a lot of work from us focused around co-pilot and co-pilot studio as that's one of our big

pushes here for Pragmatic Works in the in the foreseeable future. So, what I'm going to do here is go ahead and select

create. And then this is where I'm going to create my new agent just by selecting on

new agent right there. All right. So, here we are with our agent. So, first things first, we're

going to get some prompts here about what would we like to make? How do we want to do things? To make things easy,

what I've done was I've added in within our one drive folder here or the folder I moved into one drive some details

about our agent that you can copy and paste if you want, including the name, a brief description, some of those things

there to help us out with uh different parts here. So, if you come here and click on the autonomous agent details,

you could see here we have our name, description, all the instructions we'll be utilizing. This could be something

that we can absolutely come back to and just kind of copy and paste if you like and then modify to make life a little

bit easier. So, I wanted to make it as easy as possible to just grab things, copy, paste, go ahead from there. If you

want to go ahead and type it out yourself and really customize each piece, absolutely do that as well. Feel

free to do whatever makes uh makes the most sense for you. I'm going to keep this all consistent here. So, I'm going

to use my agent name here, which is going to be Pragmatic Works Landscaping Agent. That's going to be the name. The

description here is what I want my agent to do. Okay. So, you can see here that's kind of the whole purpose of the agent.

So, let's take a look at the prompt here first. Coming with co-pilot to help us do this. Now, what you can see here

says, "Hello, I'm here to help build an agent so you can get more done." Says something like, "Provide best practices

for project manager. Help my teammates onboard a new project. What would you like to make?" Well, I'm actually going

to go grab from our file here the agent description. I'm going to just use that to help us. So, I'm going to copy that

out and pass that in here and just click paste. Okay. And it should say and autonomous the agent. There we go. Fix

that there. And we can go ahead and send it. And we're going to get a couple

follow-up information uh details here coming from Co-Pilot to help go ahead and structure the agent as much as

possible. So, you'll see here you have a lot of core information behavior we can kind of add to if we want. We could

continue to go down this or we could go ahead and customize it ourselves here. So, if you want, go ahead and keep

answering questions. Let co-pilot assist you. Like for this next one, what do you want to call this? Well, I already have

an idea of what I want to call it. So, maybe I'll just continue with this last piece and then I'll do the rest myself

afterwards. So, I'm going to call it the Pragmatic Works Landscaping Agent. So, I'm going to say right here, call it

Pragmatic Works Landscaping Agent. I'll just put some double quotes around it just so it knows exactly what I'm going

to be doing there. All right. So, there we go. The agent's going to be doing that. We can go ahead

and do other things and continue on again with that conversation with co-pilot. However, what I'm going to do

is I'm going to skip a couple of these things and we're just going to get straight to building this out. So, I'm

going to select up here in the upper right hand corner, skip to configure. This is going to essentially get us

right into the name it, describe it, do all these things, right? And maybe have some suggested prompts and all these

other things that it can handle. So you can see here we have all that information. So our descriptions in it

gives us some basic instructions to begin with. Escalate, communicate, all these things. Copilot wrote them for us,

which is actually really, really nice to have. Right. So we get to be able to go through the entire process here and

allow Copilot to assist us in in all these different tasks. At this point, I think we're ready to go ahead and create

this. If I wanted to change the icon, I could do that as well. Um, you could kind of throw that in there. Now, I do

have an icon, of course. I'm going to throw everything in here inside of our Excel file or, excuse me, our folder

here. We do have this logo, this PNG logo there. If you want to utilize, go ahead and do that, too, if you really

care for it. Uh, I might just change it real fast. And you can go ahead and grab that from there. So, let me go ahead and

open that up. Let's see if I can find that real quick. Uh, let's go here. And I want to Oh, it's going to point to one

drive. You know what? Let me go ahead and do that later. I'll save that to my desktop and pull it later. It's in this

other account for now. So, I'm going to go ahead and and click cancel on that. And yeah, you know what? I think that's

good. Let's just create it. Just go right in. All right. Now, as it sets up our agent,

really, the next thing that we're going to be focused on is remember this is all about making this an autonomous agent.

That's the big push for us here today. So what we want to be able to do is not just come in and do your classic topics

and knowledge sources and have it just, you know, do exactly as we train it. We wanted to really take over that task,

take over that role to determine what to do next. So what we need need to do here is start off by coming down and setting

up a trigger. Now the triggers, that's the key to really setting this to be autonomous. All right. So building

blocks in autonomous agent again starting with that trigger. This is what the autonomous agent needs to function.

It's the main piece. Just like if you have some familiarity with Microsoft Power Automate, every single cloud flow

we have we have with Power Automate requires a trigger. We have three different types of triggers with Power

Automate cloud. Well, here with our autonomous agent, it's very similar in that. However, it's a little bit

different in the way things work. The big difference between working with Power Automate and the triggers and all

the actions that come with that and then Copa Studio autonomous agent is when we work with Power Automate, we determine

first, second, third, fourth, fifth, and so on steps in that specific order. Of course, we can add in our for each

loops, our conditionals, all the extra parts that we want to add into those flows, but it's really that very, very

specific order of operations. Co-pilot autonomous agents are a little bit different. This is where we want it

to, yes, trigger by some type of event or some uh different things that we have, but we want it to be able to

determine for itself how to complete the tasks, when to do things, where to go based on the information and the

instructions we provide it. So, it's a little bit different than Power Automate where Power Automate is a little bit

more strict, a little bit more stratified, and these autonomous agents are a little bit open-minded, right?

they can kind of do a couple different things. We don't have to complete things in the exact order we set. We can let

the agent take over for us from there. So here when we talk about our building blocks, really we need a trigger. We

need something to say, all right, how should this begin? What are we monitoring? What are the couple

different things we want to focus on? And we're going to do it when a new farm's response is submitted. Then we

can give it some knowledge sources if we want. Like for instance, I could pass in pragmaticworks.com

or another web page, allow it to read off information from that web page, maybe from the about or the Q&A section,

generalformational pieces, our classes, whatever it may be. We can go past that in and allow the agent to go

automatically determine where and when it needs to pull information from the websites. We could even add in different

tools. These tools as we go through them in a little bit you're going to see are they're power platform connectors. So

it's the same similar actions that we have with Power Automate and Power Apps that we can utilize here in our agent

and just say we want to use this tool. Let the AI agent like the autonomous agent determine when to do so. So

instead of just making it as a step it just this is what we want to utilize. Go ahead and do that as necessary. So you

see some of the ones that we're going to focus on here today. We could do get response details, list rows present and

a table for Excel, add a row and a table for Excel, send an email for for Outlook, write a draft email, post a

message in Teams, all these different things that you can employ using Power Automate, we can have our autonomous

agent utilize as well. Then finally, the big part about things as we go through is making sure our instructions are

going to be really important. They're going to make sure that we let the agent know how it is supposed to work. What is

it supposed to do? Give it the guard rails for us so it knows exactly what we're expecting it to be able to

complete. That's going to be a big picture for us. But again, to get there, we need to start off with our trigger.

So, when we think about triggers here within Copilot Studio and our autonomous agent, these triggers are going to allow

the agent to run autonomously. That's the whole point about this. It starts by itself. It reads an event. It looks for

something to occur and then just goes on its own from there. We can have it based on external events to that are connected

to that agent through this trigger. And then again, all these triggers are the ones that we can employ using Power

Automate as well. So we get to really have that that kind of duality between our power automate cloud flows that are

very very specific stepby-step important taskbased things and then our autonomous agent to kind of just do all the rest

handle all those other cases that may come in and let it determine how it needs to work. As you can see here on

screen that little screenshot those are the triggers that we have. Those are just some of the featured ones and we

can search through and find more very very similar to how we would look in a cloudflow. So it's really nice to be

able to to have for us. Now when we work with these triggers, it actually what will happen is when we employ a trigger

within Copilot Studio and these autonomous agents is that it's going to go ahead and it's actually going to

create a Power Automate workflow for us. So the agent is going to kick off the trigger within Power Automate which will

then pass details back into the agent. So, it uses the pre-built API connections, those Power Platform

connectors available to then go ahead and the agent says, "Yep, the event just occurred. Go ahead and do the the task,

go get the information, go determine whatever it is, grab the email, whatever it may be, get those details, get that

output, and then pass that into the agent so it can determine what to do from there next." Which means it could

even trigger off another session. it can trigger off something else that occurs because we we're not limited to just one

thing. We can stack this and make this truly an autonomous agent that does a lot for us, which is actually really

really nice to have. So, let's go do it. Let's add in a trigger into our autonomous agent that

we're developing so that we can go ahead and have it just run whenever we need it to go. All right. So, let's go do that

here and we're going to add in our trigger. Now, the way that we're going to add in our trigger. There goes my

screen. We're going to add in our trigger is just click right here. You could scroll on down and select our

triggers right here near the bottom and add a trigger for us here since we are utilizing Microsoft Forms. Well, that's

the trigger we're going to have. You can see our recurrence trigger like run on a schedule like again Power Automate

Cloudflow trigger there. We want to of course use it when a new form submission comes in. So, that's right here. when a

new response is submitted with Microsoft Forms. So, I'm going to go just click on it. If you want to see all the others,

just go ahead and search all or select all. You can search through or go through and just kind of give yourself a

nice little scroll of a lot of the triggers that we have there. But again, we're going to be using this this one up

at the top when a new response is submitted. So, I'll select next. Now, as we go through this with our

trigger, if you again have that familiarity within the Power Platform connectors like via Power Automate, you

are going to see that it's to set things up to work with the the parameters and the different settings within our

triggers and our tools that we're going to employ. They're very similar. We need to make sure we're pointing to which

form we want. Then, we're going to say what to do with it. When we do our other actions, our other tools that we have,

we're going to say, "Well, where's the file? what table are we looking at? What are we sending? What's in the email?

What's the subject? All those things. We get to go ahead and and do all those parameters here when we actually focus

on the connector. So, here's our trigger. It looks like my connections are good. Just single sign on here with

Microsoft helps us do that nice and quick. And then we can select next. Now, here is where we need to determine

what we're actually going to pull from. So, you need to say all right, which form are we going to monitor

essentially. So I can select here in this dropdown and we should have a full list of our forms. Now if you don't see

your form, okay, if you don't see it at all, it's like the the list is empty. You're not finding it. Well, it's

looking for the form ID. So you can go over to Microsoft forms and you can find the form ID. That's just simply going to

come here inside of our URL here right at the top. Okay, you can see here you could just grab all of that there.

There's your form ID. copy and paste that in and it will go ahead and find it the same. If not, if it's that may be a

little bit too advanced for you, just give yourself a refresh. Refresh the browser that you have here with your

agent. Go ahead and close this. Give it a nice refresh. That usually solves that problem as well. It just needs to make

that connection again and view all the the things that we have already made. So, I have mine done. So, I'm going to

select that there. And then go ahead and create our trigger. And that's really all we need to do from the trigger

perspective. Now, do we want to go in and customize that even further? Yeah, absolutely. We can do that. We can make

f further changes if as necessary. Maybe change the instructions. So, instead of using content from the body, we can add

pieces to that or more uh guard rails on how this is supposed to work. But that's the nice piece about working with the

power platform, of course, in this no code, low code platform is a lot of it is just out of the box clicks. Click

yourself to success and then use what's already pre-built for you. All right. So, there it is. It's done. It's

successfully added. Says go ahead and test it to ensure it's working properly. Okay. Well, before we actually test it

now, we can test it right away. Before we actually test it, well, we need to actually submit a form to see if it

works at all. Okay. So, let's do that. Let's go ahead and test this out by actually submitting a form, seeing if it

recognized that the form was submitted. We'll kind of take a look at how that works here. So, to do so, I'm going to

go over to Microsoft Forms. Okay. I'm going to go to my form here. I'm in my preview mode right now. All right. So,

again, if you're not in this where you can actually type in and submit something, make sure if I go back here

at the very top, you're selecting preview right next to the collect responses button there. So, preview and

then go ahead and put in your information. So, I'm just going to put in some kind of dummy data here. So,

I'll do Jonathan. I'll do Jonathan sample.com. And for my zip code, well, let's think

about this because we're going to use this later on to determine a little which make sure it's actually working

the correct way. Well, if I just go to my Excel file, like let's say I want to use one of these zip codes. So, let's

say I want to use um the San Marco area here in Jacksonville. So, 32207. That's what I'm going to put in here for our

first one. And just make sure that it when we actually let this run later on, it looks to the right thing. So, 32207.

All right. I'm going to put that in there. What am I interested in? Just general lawn maintenance is fine for me.

Um, what are any details? I need someone to cut my grass every other week. Now, I know in Florida

if that you only cut your lawn every other week, it's going to be thick. It's going to be real tall. So, probably

every week would be better. But, hey, we'll just do it this way. And then, let's say I found out via social media.

Maybe we go go that way. All right. So, I'm going to submit this. It's going to store that. Okay. There it goes. Our

response is submitted. I'm going to go ahead and choose submit another response for now just to kind of get that out of

the way. And then go over to Copilot Studio here within our agent. And in order to test to see, well, did that

actually work? Like is it actually showing up? When we come over here to triggers, if you take a look at this

button right here, the little beaker icon, that's our testing button. So, you can select that to test the trigger.

Kind of similar to Power Automate, has that test beaker icon as well. So, I can select on it here. It's going to give me

my pop out. Oh, it recognized that look at that. There was a form response that just went through, I can go ahead and

choose start testing. And then when I choose start testing and as as it starts to spin, what I'm next going to do is

I'm going to focus on this activity map. You notice it automatically shows up for us. The activity map here, okay, is we

want to come in and make sure that we see everything come together. We want to watch it come in front of us. So let's

see here. I'm going to click got it. And it looks like here I'm getting an error message. The content was filtered due to

responsible AI restrictions. Now the reason why we're seeing this and sometimes this occurs within this error

message is it's largely due to the instructions that we have within our instructions. If we're saying go do

this, go find this information but not really putting any real guard rails on things. That's where sometimes you'll

see this. So let's go back to our overview real quick. And you can see here I have a lot of instructions, a lot

of just here in this hyphenated bullet list. Well, what I can do is because this is saying do all these things, make

sure you do that, do all these extras, and I'm having this random trigger essentially occur. It's that, you know,

the agents like, well, hold on a minute. We have this responsible AI. We're really not sure what to do. So, the way

to get around it, especially because we're just in the building phase here, is let's go ahead and select edit and

remove all of that out of there. All right. So, I'm going to cut all that out. And we're going to make sure we

just go ahead and save it and remove every piece. Okay. So, now that's going to be gone there. We go ahead and we got

rid of our instructions. We'll put some back in here. Don't you worry, we're definitely going to put some back in a

little bit here. And what we can then do is just go back over, refresh our agent test here, and do it once more. Let's

give it another test and see what happens. All right. So, I'm going to go back over to my little beaker here to

test my trigger. Select that. There it is. Same trigger. We only have the one. Go ahead and send it again and let's see

what happens. There you go. Now it's saying, "Oh, the trigger was detected, but we're really not sure what to do

there." So, it reads received content from this web hook. It still says we're not really sure what to do with that.

Well, we had to think about this. Well, we didn't really say when it's triggered, do these next things. look

for this trigger in the instructions and then go ahead and follow up with the next steps. Which means we really need

to go ahead and actually say what are we trying to do? What what do we want our agent to complete so that this can

actually work. So let's go ahead and add in our next stage. This works. We don't have any error messages, right? It's

just saying it's just not sure what to do next. That's what we're getting here. So let's add in the next piece here. And

that's going to say, "All right, when it's triggered, do all of these different things. Go ahead and search

through here, find this, send this info, all that good stuff." Let's take a look at the next part of our building blocks.

We have our trigger. We can pass in knowledge. You can see there is looking for knowledge. We'll skip that here for

today. What we want to focus on now are tools. The tools here within our agent are the Power Platform connectors that

we want to utilize. What do we want this agent to be able to do? Right? So, we're going to connect to our line of business

systems, automate our business process and task by using our pre-built connectors from the Power Platform, our

custom connectors that we can include into the Power Platform, building it there, bringing it from a Postman

collection or others. We can use our flows with Power Automate call to a flow. We can build in prompts and

co-pilot prompts and even skills using our Azurebot framework as well to say okay do these things automatically

determine based upon what's happening from the trigger and the instructions we provide automatically determine what to

do and here's your set of skills that you can complete. Here's the tools at your disposal to go ahead and accomplish

the final task automatically for me each time. So now when we work with these tools, that's really what's going to be

the big part about the autonomous agent. That's what's going to allow it to go ahead and complete things for us. We

need to have the com the combination of our trigger and the tools together and then the instructions on top of it to

say, okay, you have your trigger, you have your tools, this is how to use them. All right, so that's exactly what

we're going to go ahead and add in here. Next is exactly, okay, what are we going to build? what are we going to do and

then add in the next pieces. So, we have a few tools to add in. So, I'm going to come on over here to the tools section

here in Copilot Studio. We're going to create our very first tool. So, go ahead and select add a tool. And when you do

that, you can see we have our popup here and we can go ahead and choose uh which tool we want to employ. You can see we

have our featured tools. We could go to see all. We have different connectors and workflows and different protocol

options. You can see that suggestions. You can even search for it, right? Depends on what you want to accomplish.

I find that it's really easiest by going to the all section here or by searching to go ahead and find one you want,

right? You can kind of scroll down and see, oh my goodness, there's so many different options to choose from. Now, I

do as I say that I know exactly what I want to do here is say, all right, if you think about the process for us here

within our autonomous agent when it begins with our trigger, right? Think about the whole idea of the task base

that everybody can do it by hand. when it begins with the trigger, it reads from our uh our form, right? It's going

to read from the form itself. And then what it's going to do is it's going to have to determine, okay, what to do

next. So, if we're reading from the form, we need to be able to get the the responses, go kind of go get what's kind

of been given to us. Then what we want to be able to do is using those responses, go ahead and compare the zip

code against our list of our employees and their range or their area where they cover based on the zip code. Once we do

that, then we can do the next pieces. So again, once this trigger starts, we need to be able to get the details from this,

all the different answers, compare it against what's in our table in that Excel file, and then let's figure out

what should we do after that with it. All right. So the next thing we need to do here if we're going into our tools is

well we need to go back to forms knowing what I know about power automate power platform connectors is working with

Microsoft forms the trigger when a form response is submitted just gives us the ID of that response. It doesn't actually

give us access to the data. So, let me go ahead and search for forms here real quick.

And let's make sure that we can go ahead and utilize a tool to get the response details.

Let's see here. Maybe I'll just go to connector there and see. We can go to forms. We want to go to Microsoft forms.

So, we can go ahead and find that here. We might have to just search for Microsoft forms. It is called get

response details. You know what? I might just say that in the beginning to make it a little bit easier to find the exact

one I want. All right, there it is. Get response details Microsoft Forms. All right, so

we're going to use that one here first. Think about kind of the order of operations we're going to go with. So I

go ahead and click on it. Then I'm going to go choose add and configure. Yes, we could just say add it to the agent. let

it go do its thing. But we definitely want to configure because we need to say, well, which form are we going to

get the details from? Which response are we going to get the details for? So, we need to go ahead and configure this as

well. So, we're going to do that for all of our different tools. Make sure you're not just adding to the agent. We

definitely need to configure and customize how that's going to work. All right. So, the tool is added in

here. We can see there it is. We have a brief description of what exactly this tool is going to do. Then what we need

to do is come here to our additional details. This is a key step that if you don't do it, it's going to drive you a

little crazy. You're going to miss this piece. You're going to be a little frustrated because right here, if I open

our additional details, the place that we want to go is right here with our authentication.

This authentication is saying whether this action uses your credentials or by the end user. Right now, it's going to

use the endusers credentials, which means it's going to ask them to sign in in order to go and access the form.

Well, it's my form. And if I open up to this this up to the public and allow it to be like anonymous users, they're not

going to sign into my Microsoft account to do so. So, I'm going to come here to authentication and say no, pass through

the owner's credentials. Okay, that's one big key factor here that again, you're going to drive yourself crazy

left and right if you don't do that piece if you want to open this up to outside users. Then we're going to come

down here to our inputs. And on the inputs, this is where we need to say, okay, which form and which response ID.

Right now, it's going to dynamically fill it with AI, which we could utilize, but I only want to focus on one of my

forms, which means I'm going to select the dropown and choose custom value. By doing this, I can say which form I want

to use and go ahead and click there. And there is our form ID. The response ID, we

could do the same way, but really we wanted to determine which one, right? Whichever one comes in and then kind of

launch from there. So, we're going to keep response ID dynamically filled. If we went here and chose custom value and

we selected in here, there's really no way to pass in any dynamic content. For those of us that know Power Automate,

there's no way to pass that in here and say, "Well, the one that just triggered." We want that to

automatically be determined by AI, right? Let it figure out which one just goes through. It triggers, capture that

info, go from there. Now, we've already proven, we know it triggers. There it is. Right? Here's our information.

Here's our form ID. Right? Here's our response ID right there. That's our JSON object that we're looking at right

there. There's my response ID from the first one. It's labeled number one. So, it we know it's there. Let the AI go

ahead and grab it for us. That's essentially what we're saying. All right. So, we're going to keep it like

that and go ahead and choose save. Make sure it's enabled, of course, there at the top.

All right. So, there's our first one. There's our get response details. Now, we can go in, update the instructions,

and then kind of do one step at a time. But while we're building here these tools, we might as well just think,

well, what else are we going to use? What are the other things that we want to do when we go ahead and work with

this entire scenario? Well, as I mentioned, the next thing I want to go ahead and then compare against my

employees and the zip code that they cover. So, that means when I come here into Copilot Studio, I need a way of

reading that Excel file. So, I'm going to go over to my tools again, and we're going to add another tool. Okay, we have

our get response details from our form. I'm going to go ahead and choose add a tool. And then this one's going to be

our Excel online connector. It's one of the first ones right here. You can see Excel online, data versse, teams, one

drive for business, Service Now, SharePoint, Planner, and so on and so forth, Outlook, the more like widely

used popular ones here. So, let's go ahead and use the Excel online one. All right. And here we have our

connector options here. So these are the ones that we have available for us in a lot of different locations here.

Obviously copilot studio is no different. The one we want to choose in this case is list rows present in table.

Return the entire Excel table and then dynamically figure out based upon our input there which is our zip code which

record we want to return. Right? That's really we're going to focus on here. So go ahead, select list present in table

make your connection. If it's not connected, go ahead and create a new connection. All right, there's our Excel

online connection and then click create. It's going to go ahead and ask us to sign in again.

Single sign on should be enabled so we don't have to put in our authentication and all that again, but it might change

for all of us. So there you go. I'm logged in. I'm going to choose added configure again because I want to say

well which Excel file are we going to open which table are we going to use to compare right we need to point to those

specifically so there it is list rows present in a table perfect okay there's our

description just give me everything we could say do this do that we can kind of narrow the scope a little bit here once

again we need to make sure the additional details we come in here to authentication and we say no pass

through the own the tool owner credentials use my credentials to use the Excel file

that I'm in control of because I need it to create automatically. All right. So, we're going to do that here. Then,

scroll on down and let's do our inputs again. The location, library, file, and table. All right. So, I'm going to for

all of these, I'm going to select the drop down here. Okay. And we're going to choose custom value. So, then we can say

where is this being stored? Mine's in one drive for business. Okay. Which document library is it in?

Okay. Custom value there. And I'll make sure to point to the right one. It's in one drive. Okay. Which

file? Now, this is going to require us to go down the folder path and select the very specific file here. So, we'll

do custom value. Again, we're going to click on our little folder icon here and make sure we're going to the right one.

Mine is in here, my autonomous agents course resources. and we are going to use our employee

information. Okay, that's what's going to be the one that we need to use to pull and to read from. All right, so

there we are. And then the final one is well, which table? Cuz I can have multiple tables in an Excel file, right?

We can have a lot of them there. So I'm going to make sure we're choosing the exact one. Custom value. I only have one

table, so that's easy enough. So we can come in here and it should be labeled table one.

There it is. Table one. Perfect. That's been done. We're good to go there. So now, if we think about, okay, we have

our trigger when the form response comes in. Then what we want it to do, right, we want it to be able to determine this.

Okay, go get the details and then compare against the what's in this Excel table. We're going to have to tell it

that inside of our instructions to tell how to use the different tools. You're only as good as your instructions,

right? Think of it as the difference when we get there is utilizing a GPS or a self-driving car. Well, we want to be

able to have it. We know where to go, but the self-driving car needs to know like what's the final spot, right? We

know it'll determine how to get there for itself, but what's the final location we want to get to? The

instructions are going to be the big case for us. So, I'm going to go ahead and click save. And then we have just a

few more to work with here. So, we might as well just kind of put them all together here all at once. So, we have

that one. Let's go back to our tools. And then, okay, we have our response detail. We're going to go ahead and open

up our table to get the full which which person are we going to go ahead and um assign this to. Then, what we need to do

is let's let them know it's been assigned to though. Okay. So, we're going to do that and really two

different ways. One way is I want to go find that employees email and email them. Hey, a new assignment has come in

for this request. Okay. Now, obviously, they're all going to the same email address for me to test this today, but

you can see that this is dynamic. We can go and pull it that way, right? Matching whoever that person is. On top of that,

once that email goes out, what I also want to be able to do is in this this folder that I have here for our course

materials or course resources, I have another Excel file. What I also wanted to be able to do is after that

individual has been notified that something's been assigned to them dynamically here, I want to log that in

this Excel table. So you can see here we have our customer name, email, zip code, interested service, product description,

assigned employee name and email, and how they heard about us. Essentially, what I want to do is take information

from the form and the employee details from the Excel file, put them together in my log as well. So, we can store this

later on. Maybe I want to pull into PowerBI. I want to see it maybe a a Canvas app with Power Apps. How do I

want to use this in the future? This log will be certainly helpful for us. So, I want to have both of those things done

to notify and to to store that log. Which means if I come back here to my agent, we got to create some more tools.

So, let's go ahead and do that. The next tool I'll do here is we might as well stay in the Excel world. We're just

doing it. So, let's go to stay there and go ahead and add a row into our Excel table. So, I'll go back, add a tool,

choose Excel online, and we're going to go ahead and we want to

let's go ahead and find it. There it is. It went right past it. Add a row into a table.

We should be connected already because we just used this connector. So let's go add and configure.

All right, we're adding our row. Remember authentication set to no by now. We're just going to keep doing it.

So use my authentication. Go ahead and so you can log into my Excel file and do all that that I own. So we have to ask

the user for any of that information. Here we go. Let's go ahead and determine these. So location. Well, where is that

file located? Well, it's right next to the one I just worked with. So, I'm going to go to custom value here. Mine

is in one drive for business. Which document library? Well, I'm going to choose the specific one that is which is

the one drive. Which file specifically? Okay, I need to use the path for that. So, I'll do custom value here and select

the folder option. And I'm going to go point to that myself. Okay, my my log here. Okay, there it is.

the table. Once again, that's going to be our table that we determine or dictate which one we want to use here,

which is table one. And then the last one is the row item. Well, for row item, we don't know which row to add in. Like

we don't know what what row number it is, right? So, we absolutely want that to be done dynamically with AI. Let it

determine which row is next. figure out on its own where to add in this next value. So, we're going to keep it just

like that. All right, let's go ahead and save this one. Okay, so now we're essent we're just setting up what to do. We

haven't passed it. We're not passing in information. It should determine that all by itself. That's another cool thing

here is we're not passing in like within Power Automate, we're not seeing all the input parameters and saying this goes

here and this goes here. We're going to just tell it that in our instructions and it should do it all by itself. All

right, so we have our tools. Let's go back to tools zero. Let's make sure we have a save. It looked like it did save,

but just in case. Sometimes you'll see that popup. There we go. I'll click tools. We have our three tools. Let's

add in our email tools, right? Because we did say we want to let them know. So, if we come here to add a tool and then

we go into our Office 365 Outlook connector, you have a lot of options here as you

can see, right? When we use this this connector here for co-pilot studio within this autonomous agent that we're

trying to create, well, you'll notice is we're kind some of them not quite the same as what we usually would use within

say Power Automate. And the difference is we do have yes this send an email. However, within Copilot Studio

specifically here, the one that works best is drafting an email message and then sending the draft. So it it has it

it writes it as a draft, stores it in your Outlook account, and then goes to send the draft in staging it that way

actually works really really well rather than just going straight to sending the email. So we're going to do that. We're

going to do draft an email message to start with. All right, let's make our connection

here just like we did the Excel. Select a dropdown, create a new connection. Single sign on is going to be here for

us as well because it's all part of Office 365. So we should be able to click on create. We need to select our

email address here. Again, we should not need to use the authenticator application. Sometimes it happens, but

we shouldn't need it here. There you go. I can go ahead and choose add and configure.

All right, let's go about it here. Now, this one is a little going to be a little bit different for us when we come

in when within our draft and email message. I actually want to in this case put in a little bit more of a

descriptive message. So, for our description here, I'm going to add in this. What I want this task, this tool

to be able to do is create a summary of information from the Microsoft form response and Excel file to send a

notification of a new request. So, I'm explicitly telling it that it needs to it's going to look to combine

information from multiple different sources. Do we need this specifically here every time? No.

However, the more descriptive you can be within the tools, within your instructions, within your trigger, the

better off you're going to be. So, sometimes I put them in, sometimes I don't. As you go in and test and try to

kind of do work with it for yourself, sometimes you'll you'll realize, you know what, I actually need a little bit

more of a descriptor on there so it can know exactly how to work in the way I need it. So, just dynamically determine

that. You can kind of go back and forth and and figure that out for yourself in here. and prompt writing is going to be

a big key factor for us here. All right, so there's our description. We're going to come into our additional details. Of

course, we're going to say no again every time. So, we're going to use my credentials rather than whoever is

submitting the form, right? Something or another like that. We are then going to come in here and leave the two field

dynamic. I want my agent to automatically determine who to send it to. It's going

to read Excel and figure it out on its own. So, I'm going to leave it like that. The subject however maybe I want

to have that like a very standard subject so then the those individuals know what's coming right so maybe I'll

put that with a custom value here and stay in this um maybe new landscaping

request assignment. So it's going to assign it to an

individual. It's sending it to the individual it's going to assign it to. So I'm going to do something like that.

All right. Then the body, let it go dynamically. I want the AI to figure out what to send. Now, I'm going to give it

some guardrails again in our general instructions for our agent, but I want all of that to just come from itself.

Let the autonomous agent make that determination. Again, we could say when this is complete, what should we do?

Send a specific response or write the response to a generative AI. This response here is going to show up in the

chat. I don't really necessarily need to do that in this case unless mostly it's for

my testing purposes because in reality when this is running by itself we're not looking at the chat it's just going

right we're not focused on the chat at all here within our agent so we don't necessarily need to send a response

however it is something I use quite a bit when I am going through just general testing and building from scratch and

I'm just not sure what's happening or what needs to be changed I'll go ahead and say yeah just throw it in the chat I

need to see something you know give me what you're finding So I can compare and make sure all the the things are are

working as well as I want. Maybe filters or others. All right. So there we are. We have our inputs. By the way, we could

always add in more inputs for all of these different connectors. We have other inputs we can put in here as well.

So if we wanted to say there's a specific importance or sensitivity label, we wanted to put in attachments

or comments or something else. We can always add in more inputs and say to customize those values to set those as

custom or have it dynamically determine right here. They're all going to dynamically determine for us or just do

nothing. Right? I don't want any attachments. So I'm just going to leave attachments by itself. Right? So that's

some of the things that you could always do as well. All right. So there we have draft an email message which means that

we're going to when we have this done it's going to go via my Outlook. It's going to go to my drafts and then place

an email message in my drafts. Well, no one's going to get that if it's stuck in my draft. So, the next tool that we

need to employ here, if I go to my tools, is to send that draft message. Send it out so users can can work with

it. All right. So, we're going to come in here and add a tool. We're going to also use Office 365

Outlook. Okay. So, I'll select Office 365 Outlook there. And what we want to do is send

our draft message. So, let's go find it here. There it is on the lefth hand side for me. There we have the draft created.

Let's send the draft. Okay, we have our Outlook connector already configured. So, we're there

already. We can add and configure the tool itself. And in this case, there's really not a

whole lot for us to do. The only thing that I'm going to change here is, of course, my additional details. And I'm

going to set that authentication to no. That's it. That's all I need here because really the input just says, hey,

if it's there, what we just created, just send that one. Use AI to determine which one was just created so that we

can send it. Right? Don't just grab a random one. Make sure we're grabbing the one that was just created there with the

one tool that we just employed. So, let's go ahead and save this. All right. And now what we can do is

let's go back to our overview because we're ready to go and try to test this out and see how this works. You can see

all of our different tools here that we have, but we want to see how this works. If I were just to go ahead and test our

trigger again, it's going to do a pretty good job of like getting kind of close, but it's not going to be quite what we

want. It's really really important for us that once we add in our triggers and our tools that we work within our

instructions and we really explicitly tell our agent how it's supposed to get to the final result. How is it supposed

to figure out what to do from there? So now when we work with these instructions, right, we want to be

really, really specific in a lot of places. So it knows again, we want to make sure we're giving it the end

result. That's the big part about this when we work with again our, you know, our triggers and our tools without

knowing the final result, what we need to do in the end. You're essentially having your little agent here just walk

around a room in the dark, not knowing what to do, just trying to figure it out of like, oh, do this and send it to

nobody. So, we need to give it these instructions that are clear, concise, so the agent knows what to do. We saw

earlier that the instructions that we had were just too specific to something that the agent wasn't intending on

doing. That's why we got our error message that we had earlier. If we have all those instructions, but it's not

matching what the agent's supposed to do. you have to make sure the instructions are really really matching

so everything runs really well. So here we are within the different types of instruct the instructional things that

we can add in. So role in purpose. We think about role in purpose. We want to say okay what is the primary function?

What are we supposed to do? Explain how the agent is supposed to work. What it's supposed to say? Um what problems is it

solving? What tasks will it perform? This is really where you could say add in all of our tools like I wanted to be

triggered by this. Do these five tools afterwards that we give it the scope. What are the limits? What should it

avoid? Where are we looking? where are we not looking type of thing. How will it handle out of scope requests? Should

a response to the agent, hey, that's not something I can handle right now. Please do something else, right? Or rephrase

your question. We could do something like that. Or maybe it just doesn't run and we just going to pass in a different

response saying we couldn't we were unable to assign this and we have a, you know, final case that we do that way.

Give it context. What background information does it need to use to understand the queries effectively,

right? So, does it need to read off of um a web page or is there another knowledge source that we need to employ

in order for the agent to know exactly what to do from there? How do you provide the context? What are the ways

that we want to frame that? And of course, the tone. Okay? How should the agent respond or sound? Now, some of

these are more for your general retrieval or taskbased agents, right? That closer like the chatbot style of

agent, whereas the autonomous agent may not use all of these. However, sometimes it does, right? If you think your agent

is going to be both autonomous and be able to be that little chatbot as well, you can have all these passed in there,

too. So, that's going to be the key factors. And some best practices for us when we create our instructions are

absolutely be specific. You want to make sure that, excuse me, your agent knows what to do

and how to do it. Break the task down into small steps. In fact, put bullet points. Number the steps. So say do

this, do that, do this. So you could be very very explicit in exactly how it should work. Use very clear syntax.

Provide examples. Say when we want to go ahead and send an email, go ahead and frame this email as such. This is an

example of the body of the email might look like. So we can do all that there. Use do instead of do not. Have that more

of a positive mind frame as you do it. Do this. Go escalate here. Go complete these tasks. Don't say do this but don't

do that. Right? Sometimes that may be applicable, but we want to make sure we're really saying these are the things

you're supposed to do. Avoid uh contrasting instructions. Don't confuse it. Don't say do this, but then also do

something that's completely different. It's not going to be able to read that as easily. And of course, add knowledge

in there. So have it go read off of specific knowledge sources as possible. Again, it's going to be as applicable to

that scenario that you're working with. All right. So, let's go ahead and add some instructions into our autonomous

agent so it knows exactly how it's supposed to work. So, for us here today, what I've actually done is I've created

my instructions ahead of time. So, you can copy and paste if you want. I'll go ahead and do those and do so as well and

then explain exactly what I've created. And all that's again in our uh course resources folder. The instructions are

going to be in here in our agent details. So, if you go ahead and select your agent details, you can see here we

have our agent instructions. All right. So, I'm going to start off by utilizing the first five because these are where

we're going ahead and actually use the tools as well. So, go ahead and copy those and pass those into your

instructions in your agent. So, I'll do a nice control C on that. Come back here and we're going to go up to our

instructions and choose edit. Here's where we can then go ahead and paste in those instructions. And there you are.

Now, if you like, if you're a big app formatting and all those things, go ahead and do that as well here for us.

So, I can go ahead and kind of give some spacing and all that kind of good stuff and something like that. And um we could

just give us a little bit more spacing there and some more spacing. And I'll kind of explain what comes next after

all of these. Uh as we do that, and we'll do a little bit of this info. Just kind of I'm just going hitting enter, go

downing some spaces here to make this. and it'll explain exactly what this is supposed to do. Okay, so it looks like I

could my formatting came a little bit different. So I'm just going to hit that. So it makes it a nice block of

text there like paragraph format for us. All right. So there we are. We have our instructions. Now within our

instructions, some things to think about. You could see here I have very very specific, you know, quotes of

exactly go find this, go do that. I also have steps numbered because I wanted to complete this in a very specific type of

sequence. Now, we could just say go do that, go do this. You know, we can go ahead and build that all in here as

necessary as well. It's really going to be uh something you have to play with as you employ your agent more and more. So,

the first thing you can see here is I have for my trigger trigger when the form is submitted. Okay, so that's our

first piece. So, that's going to be the first part. Then get the response details. Now the action is called get

response details. But sometimes what you could do is if you just make that bold controlB, what you can do is say really

focus on that. Make sure you're doing this as the first thing so we can get all the information from the form. And

then what I've added in here, anything inside of these square brackets here is where I say insert dynamic content from

here's your tool. So this first one would be the get response details tool. So I'm going to go ahead and remove all

of the that within my square bracket there. And in order to add in the tool the workflow the essentially the dynamic

content again coming from our Power Automate days is we need to add in a forward slash. The forward slash will

allow us to get all of our suggestions and the different tools, the topics, the agents that we want to call to from here

including variables and power effects expressions. Well, in this one, I just put in I want to use my get response

details. That's what I'm just replacing. So, I'm going to go ahead and select that. And so, now we're going to get the

response details using this tool from that request. Right? So, we're being pretty explicit in this case of this is

exactly where you need to get the information from. Essentially, we're kind of using it like kind of like a

knowledge source in this case. Then, we're going to say, okay, extract the following fields all from that form.

Okay, good enough. Next use here's our next piece here that I'm going to pass in list rows present in table. So I'll

go ahead and do that. So there's our list rows present in table and then I said get all the rows where zip code

equals the submitted zip code from the response details. So we're going to essentially tell it how it should filter

down itself dynamically rather than writing say an O data filter query within that and writing it all from

scratch or those of us again Power Automate users and Power Apps users know what I'm talking about there to pass in

that filter. We're just telling it in instructions using some plain English here, some plain text Nashville language

to go ahead and pass that in. So nice and simple there. Then our third here, insert the dynamic content for the

drafted email message. Well, I'm going to do that here. So, let's go ahead and draft email message. Okay. And as I was

writing this out, what I'm really thinking about, okay, does this need to be in the exact order? Well, yeah, these

first few for sure, right? The first two here, get the details and figure out which row we're finding, they need to be

in that order. These others don't necessarily have to be in the same order aside from the drafting and sending the

email message, but like adding a row into a table, that could be after we list the rows, right? That's where

you're going to get a little bit more freedom of creativity and how you want this to work when you're creating your

agent yourselves. All right, so I have here draft an email message. I'm giving it this sample right here, a nice little

example. Hi, employee name inside a quote. So, it's telling it go look for the employee name and put that there in

the salutation. We could have there's a little bit of a sample text there. I'm asking for customer name, email address,

service requested, product description, asking for at least that info uh to be sent in our draft. And then we're going

to send the draft message. All right. So, I'm going to do that. Replace that as well. We're going to go send our

draft message from there. And then the final step here is something that you'll see there's a lot more text in that.

That's because I'm using add a row into a table. And what I really want to make sure is happening here is that the agent

puts the correct values in the correct columns and the correct fields in that Excel table. Especially because this is

a log. This is something I may plan to use say in a canvas app that I built or maybe with a PowerBI report later on the

down the road. I want to make sure all those are getting written to the exact same spot every single time. So that's

why you'll see that I'm even more explicit in my instructions on this one than I would be say in some of the other

ones that we have. Okay? So keep that in mind. Um you could be more or less explicit in your instructions depending

upon what exactly you're trying to accomplish. So I'll do this last one here where we're going to add a row into

a table. All right. So those are all of the steps, the instructions I want to give it. Let me give it a save here. And

then once I select save, we can go ahead and let's test it out again. Let's see what happens from here um within our

first test, right? That's going to be the first test we gave it to see that it first triggered. And let's see if it

does all of those other actions thus far. Uses the tools and completes the different tasks. So I think it's time to

test. Now, we earlier we went in and went to triggers down here and then used the beaker to test. We could do the same

thing up here in our chat. I'm just going to refresh the chat. Always refresh. Select the ellipses right here.

More and we could test the trigger from up here as well. All right. So, a couple places to do that. So, I'm going to go

ahead and test the trigger. See my one that we did earlier. Go ahead and click start testing.

And let's see if it actually does what we're asking it to do. So, get the response details. It's listing the rows.

All right. So far so good. Now, it's going to go ahead and create our email messages. Let's see if it sends it out

correctly. And we want to make sure Oh, there it's adding a row into a table there. Let's see if it's pulling in

right here. So, I'm going to go in and remember we said within our form, we wanted to go in and we're using

we said 32207, right? Which means it should be setting to Allison. There's our key. We want to

make sure that's the correct one. Okay, so real quick, I can actually tell that it's doing it correctly because if I

look here into my add a row into a table. Again, these are our Power Platform connectors that we're utilizing

here right now. I could see the row record that we're writing. This is the output that we're writing in here. This

is the object itself and the columns that we're writing to and then the values. So, it's a little bit of a JSON

object there. I can see right here assigned employee is Allison. The customer zip code is there. All the

answers to our questions from the form are written in. So that means if I go over

to my farm, oh my goodness, look at that. Let me just spread this out a little bit. You can see boom, boom,

boom. Everything is written exactly as we put it, which is perfect. Which means I should have an email too, right?

Because if this was the final step, we just verified that the data is correct. If I go over to Outlook

in my inbox, well, looks like sometimes that happens with this demo account that sometimes isn't just run here. But if I

go to my sent one, there it is. You can see that it will be sent out. Then that's the one I I had there. That's

sent from me to me. So that's why he's seeing some issues with the inbox. Don't worry about that here for today. But

there you are. There's my email, right? There's my subject. There's sent to customer name. That's what I put.

There's the email I put in. That's what I requested. I need someone to cut my grass every other week. Pretty awesome

there. So now as it happens, it just goes all by itself each and every time. And we can add in other tools. What else

should it do? Other things it should employ all part of this that it can then figure out dynamically how to, you know,

add pieces to to the puzzle here. What else should it be able to do as our personalized assistant? This is just one

little scenario. But of course, we give our agent more tools. it can go ahead and use those tools as its disposal. We

in this case within our instructions decide, you know what, I want to be a little bit more explicit with my

instructions. Do this, then this, then that. But if we just want to say run all these things, we can just tell it in the

instructions when this occurs, do these steps. And if we don't put it in a very, very specific order, we can allow it to

go and determine what the best sequence is all for itself. Now, that's a pretty cool feature there. But some of you may

be saying, well, hold on a minute. Is that kind of like Power Automate? Not really because remember Power Automate

is very very this to that to this to that. We kind of got close, but we can allow it to take over for itself and

dynamically determine read data on its own, do the filtering on its own, which it did, and do all the other things,

right? That's where the the differences really lie. And this last piece that we're going to add in here is the big

point that we want to add in the ability to pass off this agent to another agent to complete other tasks as it's ne as it

deems necessary. So that's another big piece for us here to be able to go from one agent to another.

So agentto agent handling is something that is so very nice to work with here in co-pilot studio where we can connect

to other agents and hand off interactions and respond to autonomous triggers. So we create a couple

different agents either full agents or what we call our child agents to then just go run all by themselves. let our

hub here, our agent, our main one, determine which one it needs to call to, what data to pass, and everything

happens all by itself. This is a preview. This is absolutely brand new, right? So, you can still go ahead and

use it. Keep in mind, because it is still technically in preview, there may be changes to it coming up in the next

few months, in the next, you know, six, eight, 10 months, whatever it may be. However, right now, it's actually such a

great feature here. So what we could do is we can create two different types of agents to connect to. A child agent

which is essentially like an embedded lightweight version of an agent inside of our main agent here that essentially

works like a topic where we trigger a different topic and do all these things and another agent can handle that that

has its own instructions, its own ability to go ahead and utilize tools and others as well. So it's kind of a

nice lightweight version or we can connect to another full independent agent as well. So long as it's in the

same environment within the power platform. So we could say all right well one agent's our landscaping agent

another agent is going to be our marketing agent. Another agent may be our HR agent and we can connect them

together so they can communicate and do different independent things. But when one triggers, it can then say, "Oh,

actually, we need to go and get to our marketing team and make sure we update our social media or we need to make sure

we connect to our HR and make sure, hey, maybe they've done a lot of uh jobs this week. We need to pass it off to someone

else to cover that task." Or maybe they're on PTO and even though it's the right zip code, they're not going to be

able to complete that. Let's go assign it to another person. There's our pass off from one agent to another. We can

allow it determine that for itself. We can have that based on again the main events events from the main agent. We

could specify additional conditions like hey only do this if it comes from here or if the data says something else we

can apply conditional statements in there and again we can have more than one agent fire off for a single activity

which is really really really nice to be able to see. So let's go ahead and do it. We're going to use a child agent in

this one and add in one final wrinkle to our scenario. And that final wrinkle is once this is all said and done, once

this is complete, I want to be able to send a message to say an administrator, some admin, some uh supervisor, so they

know that things are actually occurring, that something went out and they get an immediate notification, say in Microsoft

Teams, that a new request came in and it was assigned to one person. So to do that, we're going to go over here to

agents. Now, we could do it from the overview as well, but I'm coming here to agents tab. Am I going to add in a new

agent? If we already had an agent built, like a fully functional independent agent built, we can connect to it. It's

another co-pilot studio existing agent. You can see here we can also do an agent in fabric as well. AI foundry coming

soon and also 365 SDK agent coming as well. One we're going to choose though here is we're going to do this

lightweight child agent. Okay, we're going to select that there. We'll give it a name. Okay. So, this one, let's say

for this agent specifically, since we're just going to essentially send a message to a supervisor, right? We're going to

call this our notify supervisor

in Teams agent, right? Super kind of basic there. And then for this one, what we want to do is say, all right, how is

this agent being triggered? What exactly is going to start the process? So, I'm going to go ahead and just simply put in

this agent is triggered when the when called by our other one. So, it knows exactly when it's supposed to begin. So,

we're not going to go ahead and and just kind of give it just overall just do whatever it wants. It only happens when

the other one says so, right? That's kind of what we're focused on here. Of course, you can see additional details.

This is where we have our condition. We could say if there's a variable or something else that we want to build in

here, it's very, very specific that we want to pass in. It only happens if something like a mini trigger condition

in here. We can build in here as well and a priority. We're not going to do that here today. So, we could just skip

over it. And then we can give it our instructions. What should it do? Well, before we do that, let's actually say

like the task is supposed to complete, right? So, we can come in here and we can because again the instructions are

going to be a little bit dynamic here. Let's go add in our tool inside of this sub agent. Now, some of the the parts

about this is when I put a tool here, I'm going to click add right here. When I add a tool into my child agent, the

tool is actually going to be visible in the tool section of the parent agent. So, it's it may feel a little confusing.

We're like, well, it's kind of subparted. Well, just think it's associated with the parent. So, we're

actually going to see the tool alongside all the other tools we've already been using. So, we can come in here and in

this case, we're going to go to Microsoft Teams. Okay. We can go ahead and say, "Yeah,

we'll leave it." Leave here. It's going to go ahead and create our tool. Give it a second.

Looks like mine was just spinning a little bit. So, I'm going to go back and and just reconfigure it real fast. So,

let's go back in here. I'm just going to go ahead and call it again. This is going to be our um notify supervisor

then teams agent the description here. We'll pass that back in there. All right. And before I go ahead and add the

tool, since mine was just spinning there, go give us a nice little save first. Let's just make sure it saves it.

Looks like mine got stuck there. So, I'm just going to give it a save and then we can add the tool afterwards. There we

go. Agent saved. Now, I'm going to come here and let's go add our tool. All right, kind of got stuck there, so no

worries. Just a nice little refresh got us to where we want it to be. Click tools, add it. There we are. And we want

to go to Teams. Now, here inside of Teams, we can go ahead and choose exactly what we want to complete. So,

for this piece again, we want to just notify our supervisor, somebody in Teams. So, that means I'm just going to

simply post a message in a chatter channel. We could of course put a card in that chat or channel or in a shared

area or something like that, but let's just go ahead and post a message. So I'll se select that one.

Connect into teams. I'll make my connection. There we go. Just like we did with the others.

All right. And adding configure. And we're going to do this just like we did all the other

tools. We're going to configure them. make sure we're pointing to the right location. Who are we sending it to based

upon their their email address? Who is it coming from? Uh what is the authentication type? What type of

message do we want to have there as well? That's what we're going to look at here. So, here's our tool. There we go.

Post a message in a chat or channel. Let's go ahead and do our authentication first since we we know that we're going

to have to do that. go ahead and say nope just use my authentication here as the owner of the of the agent post as I

want to do this as a custom value here for post as and I'm going to choose in this case post as the flowbot post in

I'm going to choose chat with a flowbot so it shows up in teams as just coming from the workflows bot in teams so

custom value there post in is going to be chat with a flowbot right there okay post message request request there. We

don't need to worry about that. Recipient, that's really what we need to focus on again. Who's receiving this?

Well, let's go ahead and pass that in and customize that so we know who exactly is to get that response. Now,

I'm going to go ahead and grab that in here since I don't have that copied and memorized there. Let me go ahead and

grab the full one there. Uh, let me see it here and make sure I choose the whole thing.

There we go. There's my email address I want to pass in. Go ahead, put yours in there, too. Okay, so there's the email,

the message. Let it go dynamic. Let it dynamically fill with AI. Let it figure out what the message is. We can make

some of that within our instructions and kind of give it a guideline of exactly what the message should look like. All

right. So, there we are. We have our description, our name, all the inputs done. Go ahead and save it. What we can

then do here is go back to our agent. Okay. and open up that other agent. So, I'm going to go click on agents here now

that my tool has been saved. Here's our notify supervisor and teams agent. I'm just going to select it.

Now, I'm going to go to the instructions in here and we're going to update the instructions so we can make sure that

this agent does exactly what we want it to do, okay, within which and use the tools how we want it to do. So, I'm

going to paste in here some new instructions. We're going to run. I'll go ahead and put in my

dynamic content there. Okay. So, we're going to run our post message and chatter channel and include the assigned

employee name and project description in the message. We can say we want more things or just give a general

information about that. We can absolutely do that as well. But in this case, I just want to say run this

include at least two pieces of information. That's going to be the key factor here. All right. So, there's our

instructions for our child agent, which is again including this other tool. So, I'm going to go ahead and save that. And

we're nearly there. The last piece is we have our child agent. We know when the child agent is supposed to run because

we gave that in the description. We told it what it's supposed to do at the end within our instructions, but we didn't

tell our parent agent how to use the child agent, when to go ahead and pass information off to that child agent. So,

we need to go all the way back to our overview, all the way back to the main agent that we have here, our autonomous

agent, and update our instructions one last time. And we need to include one final piece in our instructions. And

that final piece is to go ahead and run or call the other flow or the other agent, excuse me. So, we want to add in

one more piece here. And I'm just going to go ahead and copy it from my file here because I do have it as step six

down here, which is just simply call the last piece. Call the other agent. So, I'm going to type in here. It's nice and

simple. Call the I'll put my space forward slash. And what we want to do is call the notify supervisor and teams

agent. That's it. The very last thing, go ahead and make sure that other agent kicks off. So, final save here

and we should be good to go. Now, I'm going to test this. I know something's going to happen if I test it right now.

If I were to test this right here, right now, it's going to fail because one of the rules about using this agentto agent

handoff is it only works if the main agent has been published. It's the only way this will work. So, I'm

going to go ahead and select publish and make sure my full agent is published because if not, it will not be able to

identify, recognize, and call my child agent. So, that's a key factor here. It must be published, ready to be to be

used essentially on and live waiting for the event to occur in order for this to work. Okay. So that means once it is

published, I actually don't need to click on that test button at all because if I just go to the form, add a new

response, it should go by itself. It's waiting, it's on, it's live, it will trigger on its own. The whole idea of

being autonomous, I just let it go. All right. So, let's let it publish here for a quick moment and then give it one full

test from the beginning by adding in another form response. Now, in this case, I'm going to go determine let's

see which area should I use. Let's go ahead and I will ask let's see who do I want to do some work for me here. Yep.

I'm going to choose Zane. So, I'll go ahead and do this zip code here to go to the fruit coarian south of Jacksonville

32259 is what I'm going to choose. So, let me go to my form. There it is. And put in a new one. So, my next one here

is Jonathan test 2. Let's just give it another name like that. I'll call it test 2ample.com.

My zip code here is 32259. Let me make sure I have the right one there once more. 32259. Exactly what I want.

Perfect. Then I want a design and I want I want to have new bushes and trees

on the side of my house. So I don't see my neighbor anymore. Why not, right? So let's put

that in there. How did I hear about us? a family friend or uh told us or a friend or family referral there and

let's give it a submit and let's see what happens from there. All right, submit that.

And now we're just in the waiting game. We're not going to go ahead here and use the map, the activity map, because the