Hi everyone, welcome to building multi agent systems with MCP

and copilot Studio.

My name is Junkar and I'm a Product Manager with

copilot Studio.

So our agenda for the next 45 minutes is we

will go through model contacts protocol in copilot Studio along

with showing you a great customer showcase.

We will discuss multi agent frameworks and lastly bring it

all together.

So a very brief overview of what is MCP.

For those that may be unfamiliar, MCP is an open

protocol that creates common language between applications and LLMS.

So instead of every system building its own custom bridge,

MCP acts like an air traffic control of AI.

So it coordinates how agents access information, tools and services

in a very predictable and standardised way.

It brings order to what used to be a maze

of one off integrations.

So with MCP, you have MCP hosts such as VS

Code and Copilot Studio that want to access data, and

then you have MCP clients that want to maintain these

one-on-one connections with these servers.

Lastly, you have MCP servers.

These are lightweight programs that each expose specific capabilities via

MCP.

And here is a brief overview of the MCP Microsoft

ecosystem.

Microsoft is certainly investing heavily in Model Contacts Protocol.

As you can see on the screen, we have several

MCP clients and hosts, many tools, many registries, as well

as several platforms where you can build local and remote

MCP servers.

Now let's talk about the end to end experience of

MCP in copilot Studio.

Over the last several months, we focused heavily on providing

A seamless experience in copilot studio that allows you to

set up, streamline and share your MCP servers.

What does this mean?

Let's go through it step by step.

For set up, we have a simple MCP onboarding wizard

where you can Simply put in your server name, server

description, and your server URL.

What this does in the back end is it creates

a Power Platform connector.

Copilot Studio leverages the Power Platform Connector infrastructure to expose

MCP servers and this allows our admins, our makers, our

users to continue leveraging all of the security and governance

capabilities that exist today via the connector infrastructure.

Additionally, we now also support full dynamic Oauth 2 point

O and what this means is this automatically now resolves

client specific authentication parameters which further streamlines the onboarding process.

With Streamline, our goal is simple enhance the MCP maker

experience.

We now support both MCP tools and resources giving builders

more flexibility than ever.

We've also introduced selective tool integration that allows a maker

to enable or disable specific tools depending on your agentic

scenarios.

And finally, makers now also have full error diagnostics and

troubleshooting, making it far easier to understand and optimize what's

actually happening under the hood.

And lastly, you can easily share your MCP server and

make it available in our MCSMCP catalog by simply certifying

and publishing your MCP connector.

Now let's take a look at this in action.

All.

Right here we are in copilot studio and I have

an agent that's created if I go to add a

tool, click on new tool and select Model Context protocol.

This is where you see our setup wizard, our onboarding

wizard, where as I mentioned you can put in your

server name, description and URL.

Clicking on Oauth 2 point OI see many options including

Dynamic Discovery.

Clicking on the Filter model Context protocol will show you

all of our current available MCP servers that are already

in the product.

In this case, I've already added the E-mail Management MCP

server to my agent.

So if I go ahead and click on it, you

can see all of the tools that come with this

MCP server and their respective descriptions.

Now let's say for this agent, I did not want

my agent to send any emails, but only retrieve them.

I can disable this toggle that is Allow all and

then disable the send e-mail.

Now let's ask the agent a question.

All right, so as you can see on the left,

the e-mail management MCP server was initialized and I can

see which specific tool was invoked.

And here's the response.

The last e-mail I received was that a copilot studio

agent was shared with me by a colleague of mine.

And to show you, I'll also switch over to my

Outlook inbox.

And as you can see, on November 12th, this indeed

was the last e-mail that was shared with me, which

was this Copilot Studio agent.

So to kind of summarise just everything we've already discussed,

right, everything that MCP allows in copilot Studio, you can

connect your agents to several MCP servers and acts and

access the latest in actions and knowledge.

You can access many of our MCP servers available in

the catalog.

You can apply enterprise grade, enterprise grade security such as

DLP, virtual networks and authentication.

And lastly, you have enhanced analytics and tracing.

And here's a full view of all of the MCP

servers available today.

In Copilot Studio, we have over 40 MCP servers that

are available.

Additionally, we also have many new Microsoft MCP servers to

accelerate scalability and performance across the Microsoft ecosystem, and these

include Teams, AIERP, Dynamics for Sales, Power Apps, and many

more.

And now that we've explored the technology, let's take a

look at what it enables in practice.

And for that, please join me in welcoming Ziv venturafrommonday.com

to talk about monday.com's journey with Copilot Studio and MCP.

Thank you.

Thank you Zhankar.

Hello everyone, My name is Ziv.

I'm an engineeringmanager@money.com.

First of all, I would like to thank the Microsoft

team for having me here.

I'm very excited to be on the stage.

2 weeks ago we officially announced our MCP connector for

copilot Studio And in the next 5 to 10 minutes

I'm going to walk you through our journey of building

this connector, show you how great and cool copilot Studio

is and last but not least show you a quick

demo of how it all clicks together and plays nicely.

Before I begin, I want to mention the special relationship

between Monday and Microsoft.

It's been a few years now that we are building

software together and every time the experience is so amazing.

It's so cool to see how the teams collaborate together

and build amazing product.

I think both companies share a very strong commitment to

building software with exceptional user experience.

So thank you Microsoft for being such a great partner.

The story begins a few years back when Monday made

a key decision to become an open platform.

While this means a lot of things, to put it

simple and kind of narrow it down, Monday doubled down

on its developers infrastructure.

So that means that our idea was to let external

developers build applications on top of Monday the same way

internal developers form our R&D would.

Now I know it sounds crazy, so it had.

We had to kind of stop and think how we

can make each part of the platform more flexible and

more customisable so developers from the outside could extend it.

We also invested a lot in aligning our API capabilities

to match with our UI.

So if you could do something through the user interface,

you can also do the same thing from their API.

And I'm talking about hundreds of actions.

The reason I'm telling you all this is because the

same decision from a few years back to become an

open platform really helped us when MCP was released because

we felt like readiness meets opportunity here.

And Monday really likes to adopt technologies early.

So we kind of jumped into the water and started

working on that to make it happen.

And the teams worked really hard and finally we managed

to release the first connector ofmoney.com, but something was still

missing.

And we felt like we built built a sports car,

but who was going to drive this car?

And because MCP is great, but it's still a very

technical feature.

Let me ask you a question.

Has anyone here ever tried to configure an MCP server?

Anyone.

How was the experience?

Let's get it.

So think about it for a second.

Like for a non-technical user this could be a bit

hard right?

Because you need to locate some kind of a Jason

file.

Usually they hide it in the developers section in a

dark corner and then you need to open the file

and modify it.

Make sure you don't break it, make sure you put

all the right parameters you need to save, restart your

client, figure out that you didn't install no JS and

then nothing works.

So I think you get where I'm going with this.

And again, while for software engineers this is not a

big deal at all, for everyday users that might be

a deal breaker and they'll say, you know what, I'll

pass nevermind.

So when we saw what Copilot Studio can do for

us, it was like a match made in heaven.

We felt like we are able to give this zero

configuration and seamless integration experience to our customers, and it

just worked like magic.

Like within a few clicks of a button, you can

have an agent that handles the authentication, handles pretty much

everything for you and for the user.

It's a very seamless type of experience.

Now let's watch the magic happen.

I prepared a short demo.

This is not a real customer.

Of course.

Ellie is my daughter.

She's two years old.

I don't think she's chosen as her career path yet.

And the flow is quite simple.

Ellie runs a vet clinic.

However, having all this expensive lab equipment on her premises

is costly.

So whenever Ellie needs to conduct blood tests, she sends

the samples to the lab and after a few days

the results are being pushed back to Ellie's Monday account.

So it's pretty straightforward, Ellie takes the sample, sends it

to the lab, after a few days, the results get

back and the client gets notified with the suggested treatment.

Now I'm going to show you how Ellie can use

Copilot Studio in order to create an agent that scans

the results for her and kind of notifies and flags

the specific results so she can further handle it and

with the customer.

So let's have a look here.

I have my Monday board.

It's pretty straightforward.

I have a few tests here and I have an

assignee column which is like the vet responsible to handle

this case.

Now I'm going to open copilot Studio and ask it

to scan all the results in my test board.

Notice that I didn't have to mention the board ID

or anything, it just understands it from the context.

This is Copilot Studios testing tool, which is awesome and

great.

It's super convenient to see how the MCP makes the

decision tree and what are the different tools that get

activated in the process.

And what you're about to see is that the agent

is going to automatically scan this board and start assigning

the problematic items to me.

So yeah, in the background it just executes the different

tools to invoke the assignment to me based on the

specific criteria.

And yeah, that's pretty much it.

And again, here you can see all the history and

the decision tree.

Cool.

So I think that in the multi agent world, we

are looking only at the tip of the iceberg here.

We could easily add more agents, for example, a prescription

agent that's going to print out suggested medical treatment given

a specific diagnosis.

So I think that really the sky is the limit

here and you can do pretty much anything you want

with it.

And this is going to be my last slide.

I would like to welcome on stage.

Matt.

Thank you very much.

Thank you.

Awesome awesome.

So that's a really great segue into let's wake up

my computer here into multi agent frameworks.

OK, so we've we've seen how we can grab tools

from these third party services and bring them into your

agents and it can do a bunch of magic with

them right?

And we saw a really great demo of monday.com.

We'll be back to monday.com, don't worry.

Multi agents is my favorite because this is kind of

like the peak of where we're at in terms of

AI and how do we actually build advanced systems with

them.

Because what you quickly learn as you're actually building agents

is having one single agent and asking it to do

everything is a recipe for disaster.

Instead, what you want to do is create a bunch

of tinier agents that have specific jobs and roles for

them to complete.

Now, there's two main patterns I want to instill on

everyone.

If you go to other conferences, they might go, oh,

there's like a dozen patterns to get agents to work

together.

I want to make it really simple for you all.

There's two.

You either have what we at Microsoft called connected Agents,

which is where you have a a parent agent and

a bunch of children that it kind of delegates and

assigns tasks to.

That's on the left.

And then you have on the right, right.

Yeah, workflows, which is exactly how it describes when I

tell customers, oh, you should use workflows.

They get they're like, oh, that's old technology, but it's

really helpful to have workflows because it constrains what the

agents can actually do.

You still leverage them, right?

They still use as agents.

They decide, do I approve this or reject it?

But you constrain, it's what it can do so that

when you have an automation, it actually behaves the same

99.99% of the time, right?

While still leveraging the power of AI connected agents.

If you're wondering when to use those, those are really

great for back and forth conversations where that human is

kind of acting as that, that guardrail to make sure

that the agent does what you want it to do.

And it can use its creativity to decide what its

plan should be and which of its children it should

use.

So to kind of demonstrate, there we go to demonstrate

how these agents can be used together.

What I've prepared is a demo for a ZABA benefits

agent.

It's going to be one of these parent agents that

is going to be delegating tasks to help users understand

and get support for their claims.

What we're about to see is I will have a

parent agent that calls not just copilot studio agent, but

Foundry agents.

On the left here we have a copilot studio agent

that's going to be developed by a policy team and

all they want to do is upload a bunch of

files and have it performed, rag retrieve answers and provide

them to the user.

And on the other side we have Foundry where a

more sophisticated team is going to build something that has

a workflow that uses many agents in order to submit

a claim.

It can check for things like fraud and if the

claim can be auto approved.

So without further ado, let's go ahead and jump to

my computer where we have our Zaba benefits agent.

So we're in copilot studio.

We can see the system instructions.

I've added a little line here so it'll always tell

us which agent it's invoking at any point in time.

We know about knowledges.

There's no knowledge in this thing.

We know about tools.

It has no tools, but what it does have are

sub agents.

I'm going to show you just how easy it is

to add one of these connected agents.

I'm going to actually delete the one that I have

already and I'm going to add it back.

The first one I want to add is that policy

expert from Copilot Studio.

If I go to my list of agents, I can

actually see this policy expert.

I can go to its knowledge.

It actually has a bunch of information in the form

of PDFs, and I'm going to give it to our

parent Zaba Benefits agent.

We'll go to agents, add an agent, and in this

big open empty area right here where you would see

many agents if I added them to my environment, we

can see our policy expert.

And what is exciting about Ignite this week is this

feature connecting a Copilot Studio agent is going GA, so

that's exciting.

We'll go ahead and add that.

We'll show just how easy it is.

We just add and configure and then it's added to

our agent.

And now I can ask it questions like tell me

about my gold policy because it doesn't have any knowledge

about the gold policy.

It knows, hey, I'm going to be asking the policy

expert agent from Copilot Studio.

We can see from the trace view that it has

invoked the policy expert and in any moment now, aha,

there we go.

We can see it's providing the answers about this policy,

right?

And so this is a really great way of distributing

the work to a bunch of different people in your

teams to create an agent that's really good at its

job.

You can create evaluations that prove, yes, the policy expert

really is an expert, can actually answer questions that it

needs to, and then you can just add it to

this parent agent.

If I try to then make the Zaba benefits agent

an expert in other HR benefits, you can imagine this

list going larger and larger and larger.

It would become overwhelmed and wouldn't be as good as

its job and you would have a harder time proving

that it's good at its job.

OK, so we've added our policy expert.

Nice.

Now we want to add an agent from outside of

Copilot Studio.

So I've already added it here.

Let's again just remove it to show just how easy

it is to get this set up.

I'm going to click add an agent and there is

a button here, connect to an external agent, which will

be coming next week, I've been told.

And underneath it are all the different options that we

provide in Copart Studio of connecting to different external systems.

And there's a ton of people taking pictures of it.

So like, Oh yes, take pictures, picture time.

So we've had Microsoft Fabric for a while.

I'll be showing you Foundry, Microsoft 365 Agents SDK is

if you're a pro developer and you've written some really

awesome code, you can give it to us and we'll

talk to your agent.

And then we love open source standard.

So we spent the first half talking about MCP and

how much we love MCP.

We also love some agent to agent protocol from Google,

from Google.

So let's zoom out of here.

Hopefully everyone got their pictures.

We're going to go ahead and connect to Microsoft Foundry.

If I was starting from scratch, I could create a

new connection and all it requires is my endpoint to

Microsoft Foundry, which if you're, if you're new to the

new Foundry portal, I'd highly recommend it.

It's it's sick.

It's really awesome.

We can go to the home page, copy our endpoint

and paste it in.

I'm not going to do that.

I already have my connection.

We'll select it, click next, and then we can provide

the information about my agent, the name, the description, the

agent ID.

We go back to Foundry and see our list of

agents.

These are all of the agents that I have in

this particular environment, one that does research, one that escalates

to a human, one that actually saves the claim.

And for any one of these, I could simply copy

its name, that's its ID, and I could paste it

into the agent ID.

Now I don't want to do that though, because remember

what we wanted to do is have a more sophisticated

agent that actually uses a workflow to answer or to

submit a claim.

I should say what's really cool about Foundry and I

know I'm on the Copilot Studio team, but I was

originally from Foundry and it still has a warm fuzzy

feeling in my heart is they now have this new

feature called Workflows and I've built one called Submit Claim.

And what's cool is like, you know, it's a wizzy

way like you can build a workflow, but it acts

like an agent.

I can talk to it like an agent.

Like I can say, I can say, hey, start a

claim and it will start going through this workflow and

it'll send messages back to the user.

Really cool stuff.

But because it acts like an agent, we can take

its ID, submit a claim and bring it into our

agent.

So start a claim for the user and this is

the claim submit claim agent.

Great.

Then we'll go ahead and add and configure.

And with that, we are now having copilot studio talk

to external agents.

This is super exciting because before we could talk to

like external MCP servers.

Now we can talk to external agents to test this

out.

I can ask it the same question as before.

Start a claim.

Our agent will say, oh, I'm going to start a

conversation with our Foundry agent.

Need a moment?

Now let's say start a claim.

There we go.

And within Foundry, I can actually go to our trace

view for the submit claim.

We can actually see the conversation running.

I just completed.

I can see the input that was provided by the

parent agent.

Hey, please go ahead and start a claim for this

user.

It responded back with this information and then the agent

is asking me for this information, right.

I can then continue and say, hey, it happened on

the 5th at Contoso Health.

Oops.

Let's see, we also want Seattle.

It was 500 bucks and yes, emergency.

I can send this over, it'll talk to the agent,

submit it again.

I can go back to this running conversation and see

how the parent agent provided this information.

And once it's complete, we'll see the full response and

it will answer back over here.

So that is our Foundry integration.

And if you want to learn more about this integration,

I'm going to be doing a Better Together session with

Foundry and copilot studio later this afternoon.

OK, so now let's go back to our never answer

back.

It's been approved.

And then we can go, of course, the oh, there

we go all of the different steps.

So it did work.

It did work.

Ha ha ha.

All right, OK, so recap, there's another picture time.

So with multi agent orchestration, you can do all these

fancy things.

I'm not going to bore you all by reading it

so you can look at it later on your phones.

But I guess the key reminder is connecting to Copilot

Studio agents is GA and we make it very painfully

obvious that the other ones are preview.

And the next time you see me on stage, hopefully

it'll be GA.

OK alrighty, so we learned how to connect agents.

I'm now going to use the rest of my time

giving you my kind of knowledge and expert opinion on

how to handle all these different protocols.

This can be very, very overwhelming.

We learned about MCP.

I briefly showed you agent to agent and secretly what

was powering US calling copilot studio agents, us calling foundry

agents is something called activity protocol.

OK.

It's not something new.

It's been around for almost a decade.

It's it's what actually powers every single agent that shows

up in Teams and Microsoft products to actually work there.

And I like to tell customers, if you're having to

decide, hey, I'm building an agent and I need to

decide which protocol I should use, you could use any

of these protocols.

I personally recommend Activity Protocol because not only does it

provide affordances for an agent to talk to another agent,

but it also provides affordances for the agent to talk

to a human to get things like reaction emojis and

heart emojis and typing indicators and things that you need

if you ever want your agent to appear inside of

a modern client, right?

And so to show you the power of Activity Protocol

and to sell you on using it, let's go ahead

and go back to machine and we are going to

go back to our Zava Benefits agent.

Oops.

So we go back to our Zava Benefits agents.

One of the features that's been around in Copilot Studio

for a while is called Channels and under Channels, these

are all the different areas that you can push your

agent using the Activity Protocol.

So if you build an agent with Activity Protocol, these

are all the places that you can send it to.

If I want to use something like Microsoft Teams, I

can easily select it.

I've already added the channel and then I can start

talking to this agent inside of Microsoft Teams.

Now, what I love about Activity Protocol is obviously this

is all the technology that Microsoft basically runs on, how

all of our agents talk to each other.

But you too can participate in using Activity Protocol.

We have an SDK called the Microsoft 365 Agents SDK.

You can check that out on GitHub.

And so if you're a pro developer out there in

the crowd and you're like, I too want my agent

to talk to other agents in humans, you can use

this protocol to develop that.

And it's incredibly easy to start using, in fact.

OK yes.

And we also provide a client so that if you

want to talk to an agent that speaks to activity

protocol, you can integrate it into your own applications or

your services.

So for example, thatmonday.com server, that agent that we built

earlier, wouldn't it be nice if I didn't have to

go into a chat pane and talk to it for

using it's NCP server?

What if I wanted it to be part of my

existing application to be automated in some sort of way?

And so you can use our client libraries with activity

protocol to get a client to that particular agent, start

a conversation, and then ultimately ask it questions.

And all of this is inside of our JavaScript SDK.

We also have SDKS for Python And C#.

And what this allows you to do is to take

that monday.com agent that we had earlier and actually integrate

it into a website.

So here we have a portal that it has a

form.

This is what people are used to typing in.

They hate, hate talking to chat bots.

But what we've done is we've taken this form inputs

and when they hit submit, we're actually using activity protocol,

the client to ask the agent to submit this information

and put it inside of a monday.com board.

And this is better.

This is better than just using a form submit into

monday.com.

The benefit of having an agent in between is it

can be, maybe it's too small, but it's actually looking

at the monday.com board items and seeing if there's already

a duplicate there.

And if it needs to merge it, it does find

that there's a duplicate and it goes, if we go

back to the monday.com board any minute now, we can

see that there's been a ticket updated.

And this particular ticket, we can see that it's name.

You didn't see the previous name, but the name changed

and a comment was added from the agent.

And so all this was powered basically everything that you've

seen so far in the session.

We create an agent in Copilot Studio, added an MCP

server, and then we were able to use this protocol

that allows agents to communicate with themselves, to humans, to

websites in order to drive automatic productivity with the team.

OK, and with that, that's my section.

And now we're going to give you one last thing

to take away, which is super exciting.

We're announcing here, It's part of a private preview.

You have one more picture that you need to take

a picture of.

It's a QR code, OK, but I'm not going to

be the person that announces it.

I'm actually going to be inviting Junkar back onto stage

to share that we are not just going to speak

activity protocol for agents in copilot studio.

Thank you.

Thank you, Matt, how's everyone feeling?

Are we all super excited to go build agents with

MCP and multi agent?

I can just feel the excitement in this room.

Everyone's like I just want to go out and go

build this right?

Yes.

So as Matt said, not all platforms speak activity protocol.

Now this is where things are going to get even

more exciting.

Yes, that is possible.

Imagine creating an agent once and having it available everywhere

your organization works.

That's the future we're unlocking with this next capability.

It's all about reusability, reach and removing every barrier between

your ideas and your impact.

So today we are very excited to introduce Agents as

MCP.

It's a major step towards delivering a truly seamless build

once use everywhere experience.

With this capability, any Copilot Studio agent can be transformed

into an MCP endpoint that can then be used across

many platforms including Copilot Studio, Microsoft, Foundry, Teams, many partner

ecosystems.

Additionally, with this capability, you can now create MCP servers

without writing any code.

You build your agent, you add your tools, your resources,

anything you need, transform it into an endpoint.

You can build and publish MCPS directly from copilot Studio,

making powerful integrations more accessible than ever.

If you are interested in being a part of a

private preview, please submit a request using the form available

via the QR code or using the link below.

We will be reviewing all submissions and we'll be following

up accordingly.

And with that, we want to thank everyone for your

time here today.

We hope you found this session valuable and hope you

enjoy the rest of Ignite.

That concludes the session.

Thank you for joining us and enjoy the rest of

Microsoft Ignite.