Are we good?

Oh, where must be good.

OK, Hello everyone.

Thanks for joining us.

I know that your conference is starting to wind down,

but we're going to get it started going right again

right away here.

So we're going to talk about the future of integration.

And just a bit of a spoiler, it is a

gentic.

My name is Kent Weir.

I'm a Principal Product Manager on the Azure Logic Apps

team, joined by I'm Divya.

I'm also product manager on Logic Apps team.

And yeah, let's get into it.

Alright, so let's start with talking about the landscape today,

right?

Every organization, regardless of the domains they are in, they

have business processes that run across multiple teams and multiple

systems.

And these systems often naturally don't talk to each other.

So you need a platform that can bring these together,

the systems, the services, as well as the teams and

the people who are interacting with these systems.

And that's where Logic Apps comes in.

It's a cloud based orchestration platform that acts as a

connective tissue that brings all of these systems together and

allows you to orchestrate the entire process starting from the

trigger to the final outcome.

Logic Apps has over 1400 connectors which makes this really

easy for you to build and hence gives you the

developer productivity that you look for.

Along with that, the workflows that allow you to orchestrate

these different steps together.

Now, workflows are everywhere now and workflows are not new,

right?

Deterministic workflows have always been there, used by the industries

and they continue to be the backbone of automation.

They are perfect and will remain perfect for problems that

require structured rule based processing so that they can deliver

consistency and at scale.

But what I but what AI brings is the ability

to automate a new category of problems and processes or

enhance your existing business processes that were previously either too

complex to automate or they required dynamic nature in terms

of how they went.

And agentic workflows allow you to do that because they

can understand the context and can adjust the path based

on the information that is provided to them.

So they interpret, they decide, and they adapt in ways

that were simply not possible before.

And what this means is that in real world, when

you think about this, you can essentially apply these this

to your real world problems.

Employee onboarding, for example, which was traditionally a very a

process that required people to go through a set of

steps, can now be automated with agents and can be

personalized as you're onboarding different people to your organization so

that you can summarize policies, you can tailor training, you

can in fact apply security policies and everything depending on

the employee you're onboarding to.

Likewise, insurance claims is another example of processes of industry

domains where you are probably processing hundreds or thousands of

documents in unstructured data, applying policies and making decisions.

And all of this is 80% of the time follows

a some follows a fixed path.

But then you always have these 20% of edge cases

where you need that adaptive reasoning where things go outside

the edge.

And that's why agents are adapt because they can take

that into consideration and adapt dynamically based on those inputs

and based on the desired outcomes.

And everything that I just mentioned is becomes possible with

agent loop in Azure Logic Apps.

So this is a capability that we released at Microsoft

Build earlier this year.

And this basically allows your workflows to become goal driven.

So you essentially provide your workflows goals or what you

want to achieve, provide them the model or the brain

which is via the LLM and then all the context

in terms of knowledge and tools for them to take

actions.

So with this, your workflows become smart, become intelligent, and

can take advantage of the large language models.

They become intelligent because they are able to interpret the

data and reason on top of it and then take

actions or make recommendations.

With Logic Apps.

These workflows can also become conversational and interact with each

other as well as with agents and humans on the

other side.

And finally, when you want to solve problems which require

more than one agent, then the workflow in Logic Apps

allow you to bring in multiple agents and have them

collaborate with each other to achieve those desired outcomes.

So with that, we'll jump into a demo where we

want to show you how all these things come together

in action.

Yeah.

So this demo or this use case is inspired by

some work that we've done with one of our large

banking customers in Canada and it has to do with

wealth management.

So if you think of a wealth manage manager, they're

typically working with customers and helping them prioritize their retirement

goals and their portfolio.

As you can imagine, there's a lot of different systems

that they need to actually go ahead and touch in

order to give them a great customer experience.

So that's what we've done here is we've built a

conversational agent that is actually going to allow this wealth

manager to actually go ahead and manage their customers and

all of those different interactions without actually having to leave

their agent experience.

So let's flip over to our screen.

And So what we have on screen here is Azure

Logic Apps.

We're in the designer and we're looking at the agent

loop experience.

So we have a trigger and this is going to

leverage the A to a protocol, which allows us to

have a conversation with it, but also enables those agent

to agent different architectures as well.

Next, we have the agent loop action.

And as part of this action, we go ahead and

provide a connection to an AI model.

Now in this case, we're using GPT for one.

The next thing that we need to do is go

ahead and provide a system prompt or instructions for our

agent.

Now here we're just going to go ahead and outline

that you are a wealth manager agent.

And one thing that we do want to impose is

that the agent sticks to the script.

So the script being the standard operating procedures.

Now, what does that look like?

It can be as simple as a Word document.

So here we've got a Word document that just outlines

the business process.

And if we think about how we want to use

agents, we want it to align to the business process

and we can provide those instructions in natural language.

So instead of doing all of those different conditions that

we've done before, if then else, if then else, we

can actually describe that in natural language and actually use

the agent to go ahead and execute that process for

us.

So this is just a Word document and this gets

surfaced as a tool.

So here we've got a series of tools that are

available for our agent and we've got this tool to

get the business process in this case from SharePoint.

But then we have other tools that help with retrieving

meeting notes or creating opportunities in Salesforce, getting meeting transcripts,

creating pre briefing documents, checking calendars, booking meetings and getting

customer details.

So let's head over to our chat surface here.

And so this is going to be an authenticated chat

surface.

So I'm logged in as myself and you know, back

to that whole standard operating procedures comment, let's go ahead

and see if I can order coffee.

I like coffee.

I could go for coffee now, but what's going to

happen here is that our agent is going to look

up in the standard operating procedures and see, hey, that's

not part of my scope.

So if we think about guardrails, this is one way

that you can go ahead and sort of help with

that.

Now more back to the demo or more relevant sort

of prompt would be, OK, how about retrieving account information

and portfolio information for a customer named Jordan Avery?

Now what's happening in this call, even though that happened

relatively quickly, there's a few things that are happening.

We've got a tool that'll go ahead and retrieve account

information.

We have a tool that will go ahead and get

contact information from Salesforce.

And then we also have portfolio information that's being returned

in a single call.

And that wasn't something that was hard coded, that was

just the large language model that was going to go

ahead and sort of look at the tools to see

what I need to do in order to achieve that

objective.

So here we can see their portfolio.

It's kind of heavily vested in tech and we can

see they've got NVIDIA.

And I believe Nvidia's had some recent news.

So let's go ahead and just issue a prompt saying

any news for NVIDIA?

I heard they had recent earnings and so what's going

to happen now is we're going to go out to

the web and actually get some additional information about their

earnings from NVIDIA and we can go ahead and explore

more of those links and information as we see fit.

So Next up, I want to go ahead and I've

reviewed Jordan's portfolio.

I've reviewed, you know kind of his, any news related

to his portfolio.

I want to go ahead and book a meeting with

Jordan.

So now what I'm going to go ahead and do

is issue a prompt that says go ahead and check

my calendar for December 1st.

I want to look for a 30 minute time slot.

Now what's happening here is that this is going to

use a capability called on behalf of authentication.

So because I'm logged in, it's actually going to go

ahead and use my credentials, my security context, just at

runtime to go ahead and retrieve availability from my calendar.

So if you think about how you deploy this to

your enterprise, you want these actions to run in the

context of a logged, logged in user.

And that's what's happening here.

So these are real time availability coming from my calendar.

So I think 8:30 sounds pretty good.

So I'm going to say go ahead and book that

meeting with Jordan at 8:30 AM.

But also I want you to go ahead and create

a pre meeting briefing document that I can go ahead

and review in advance of that meeting.

So let's go ahead and kick this off.

So once again, there's multiple things that are happening in

the background here.

It's going to actually go in and book that meeting

with Jordan.

It's also going to go ahead and generate a document

for us and actually send it to my inbox that

I can go ahead and review.

And so here it's just gone ahead and confirmed all

of that information with us.

And this is always dangerous doing this in your demo,

but here's my inbox and we can see that we

just received this particular briefing document.

We can go ahead, open it, review it, and you

know, make any additional notes if we wish.

But now we can feel confident heading into that meeting

with Jordan that we've got a firm agenda and I've

got their portfolio and all their holdings and also follow-ups

from previous meetings as well.

So I can go ahead and have that recap at

my fingertips.

Now what's happened here is we've gone ahead.

We've had this meeting, had it over teams.

And now what I want to do is be able

to go ahead and obtain the meeting transcript from that

particular meeting and actually go ahead and update that in

Salesforce, our CRM, so that the next time we want

to go ahead and meet with Jordan, we can actually

go ahead and review those notes.

So we'll go ahead and just issue this command.

And what this is going to do is reach out

to Graph API for that particular meeting, download the transcript,

summarize it, and then actually upload it to Salesforce as

an opportunity that's actually linked to our account.

So if we head over to Salesforce, let's just do

a refresh over here.

We're actually going to see the summary that just happened

here.

So we've got the meeting from December 1st and if

we go ahead and click into this option, we can

see all of the information that was captured and the

things that were discussed.

So this is just a great example of how you

can actually go ahead and tap into your broad set

of resources in your organization and actually bring a a

custom experience for your users that actually helps them to

be more efficient.

Now one other thing I want to quickly just touch

on is that during this event you might have heard

of a service called Foundry Control Plane.

And the, you know, the whole intent of this particular

service is that as you go ahead and deploy more

agents to your landscape, to your environment, to your enterprise,

you want to be able to see those regardless of

where they were actually constructed.

So that could be inside of Logic Apps as part

of an agent loop.

That could be SRE agent, that could be a Foundry

agent.

And what we do is we actually go ahead, when

you save your agent loop in your agentic workflow, we

actually go ahead and register that automatically with Foundry.

So here we can actually go ahead and see, I

do have that that agent that I just demoed for

you, we can go ahead and see that its source

is, is Logic App's agent loop.

We can see that it's actually running.

Now, if we did want to like dive in a

little bit deeper, we can click into it.

We can see if there was any active alerts or

any errors that took place over a specific time frame.

And you know, if for some reason we had concerns

about this running as an administrator, I could go ahead

and stop it.

So kind of the key message here is that, you

know, when you're building Logic Apps and you're building these

agentic processes, you are connecting back to the broader Microsoft

ecosystem.

You're not on an island.

And you can actually go ahead and see these inside

of Foundry.

And we've got a lot of other integrations with with

Foundry as well.

So that's a brief demo, and we certainly have more

demos for you throughout the course of the session.

So what you just saw was an example of how

you can use Logic Apps and Agent loop capabilities and

build agentic workflows and take them into production.

And we have a number of customers who are already

on this journey who are using these, who are using

the workflow and agentic capabilities in Logic Apps for building

different kind of agents for different kind of domains and

for different scenarios.

And these range from autonomous agents, which are completely running

in background, reacting to events and doing intelligent processing on

it, as well as conversational agents who are part of

your your ecosystem, interacting with your employees or are external

facing and interacting with your customers.

Alright, so, so we'd like to welcome Eric on stage,

Eric Summers.

So he's joining us from Sideris, where they've got some

particularly interesting use cases around cybersecurity.

Come on stage, let's welcome Eric.

So now, as you can imagine, the, you know, managing

cybersecurity threats is an incredibly complex topic where the volumes

of threats continue to increase.

We hear stories every day.

And naturally that continues to add stress to security and

operational teams as they try to manage those threats.

Now there is some hope.

There is some good news here.

And that's why we've got Eric from Sideres here who's

going to talk about how they've been able to leverage

Azure Logic Apps Agent Loop in order to help them

address cyber threats.

So Eric, would you mind just doing a brief introduction

for us?

Sure.

I'm Eric Summers.

I'm a senior leader here at the Sideres, specifically towards

security orchestration and artificial intelligence company.

I work for.

As you said, Sideres managed cybersecurity services provider and our

mission for our clients is to stop threats.

Sounds good to me.

So let's talk a little bit about the team.

I think we jumped ahead that builds this particular solution.

Can you tell us just a little bit of the

makeup of your team?

Yeah sure.

So as you know, one of the one of the

more interesting things about Logic Apps is that we can

bring cybersecurity expertise and get them closer to developing solutions,

closer to the problem.

So traditionally when you're thinking AI frameworks, you're thinking I

got to get my engineering teams involved.

I need to get my cybersecurity guys talking with them

and building solutions.

That's a very long process.

But with agentic loops, I can use something that cybersecurity

professionals understand, which is low code solutions and they can

actually use whatever they're dreaming, creating those solutions quickly, putting

it into production, into something that scales just like any

other system that's in production, high scalability, which is something

that Logic Apps provides and also fantastic results, great observability.

And that's that's why we're bringing our cybersecurity and cybersecurity

professionals with ejectic loops.

No, I love it.

I feel that people that are closest to the problem

are often in a good position to go ahead and

solve those problems given the right tools.

So I know you brought a use case along with

with you.

So do you mind just sharing a little bit about

this particular use case with our audience?

Sure.

So the use case that I am bringing today is

the IOC analyzer.

What it does is it takes any alert, doesn't matter

the vendor, does not matter if it comes from Microsoft

or others, it will take that data, strip it for

parts and then figure out do I have a hash,

where do I bring it to IP, so on.

But one of the key things is that why it's

called agentic loops.

If it finds additional IOC information, it will go back

through this whole process and actually go and analyse it.

And that's one of the reasons why we use agentic

loops instead of saying deterministic workflows is because sometimes you

can't actually predict the output you're going to get.

And that is one of the biggest advantages of AI.

It's incredibly agile, incredibly flexible, and sometimes you just don't

know what to expect and it can find threats that

otherwise you wouldn't even dream of.

And yeah, that's amazing.

And I would imagine as new threats emerge, it's going

to go ahead and go through the similar process.

So the solution sounds awesome.

Can you tell us just a little bit about the

benefits or some of the results that you've seen so

far?

Sure.

So probably some of the biggest benefits is the speed

of execution from development to production.

We are 23 agents in in six months over 100

workflows.

In fact, I think it's 100 and 1910 are going

into production today.

As we continue our migration path, we're seeing speed ups

and throw put advantages versus our previous vendor two to

three X times more alerts we can push down the

system.

The system scales incredibly well.

Logic Apps, if I, if I give it thousands of

alerts, it will just scale up to meet that demand.

Our previous provider couldn't do that.

And the additional thing is that because of the way

that Logic Apps is priced, there's a significant cost advantage

versus other competitors in specifically in the security orchestration space.

So we're very excited to be working with you guys

and with Logic Apps because we've just seen so many

various advantages.

No.

Amazing Amazing.

So thank you so much for joining us on stage

and sharing your story with us here today.

Yeah, that's really music to my ears.

I think it speaks to a lot of our core

objectives.

And we've built Logic Apps and Agent Loop in particular

is how we can democratize building these solutions, getting them

to market, getting them to production quickly and then being

able to realize substantial value.

So that's, I think, a great example of that.

Yeah.

And before we jump into the next segment, we just

wanted to mention this.

Earlier this week, we announced the general availability of Agent

Loop in Azure Logic App Standard SKU, which means that

if as you build these applications, they are now ready

to go into production.

Logic Apps is a platform that has been around for

more than a decade.

So now you can build these agentic capabilities also on

that well established proven enterprise ready platform.

So with that, we'll move to our next demo I

guess.

We have one slide first, I think right.

So we've talked about agent loop and the ability to

build the genetic processes.

There's another concept that I'm sure you've heard about this

week called model MCP, model context protocol.

And this allows you to go ahead and to connect

to your enterprise.

Now, if we think about Logic Apps and one of

our core capabilities is our 1400 plus out of box

connectors, this becomes quite interesting as you think about connecting

to your enterprise.

So something that we've recently introduced with both API Center

and Foundry is the ability to dynamically go ahead and

build an MCP server in Logic Apps leveraging both our

connector library, but also your existing library workflows that you

may have already gone ahead and built.

So this is one of those things where we're going

to take you through a wizard experience to show you

how to do this quickly, but you can also go

ahead and enable existing Logic Apps to be MCP enabled

as well.

So what I'm going to show you on on screen

here is this is API Center, and we've got a

similar experience in Foundry, but I can go ahead and

register an MCP server with Azure Logic Apps.

So the first thing I'm going to need to go

ahead and do is to provide an MCP server name.

So I'm going to go ahead and do that.

Descriptions are always quite useful inside of AI solutions, so

I'm going to go ahead and provide that, and then

we'll go ahead and select an existing Logic app.

If I don't have one, I can go ahead and

create one.

Now the next thing I need is I want to

go ahead and select a connector.

Now we're going to go ahead and select ServiceNow as

our connector, and then we're going to go ahead and

select a few different actions here.

So we want to create a record, we want to

list a record, and we also want to go ahead

and update a record.

Now I've selected 3 here, which is important because what

we're going to do is generate 3 different workflows and

three tools as a result.

So I'm going to go ahead and select those.

And then I need to provide a connection, which I

already have.

Now there's a little bit of configuration that we need

to go ahead and perform now.

And this is largely related to the connector.

So if we think about ServiceNow, they have a generic

approach to creating a record.

I need to now go ahead and select a particular

entity or table.

So this is where I would want to go ahead

and search for incident, and that would allow me to

go ahead and create a record for the incident table

itself.

Now we also have a series of parameters, and This

is why sometimes people say don't just take an API

and expose it as an MCP tool for good reason

here we've got 10s of different properties that would be

exposed that's going to cause confusion for the agent and

the model.

So we want to just select a specific set of

a few parameters, and we'll go ahead and select the

assignment group, the short description and the severity, and then

we'll go ahead and click save.

And we can see here that these are going to

be provided by the model.

So at runtime, those are values that are going to

have to be populated as part of that conversation.

Now, I'm not going to go ahead and configure these

other two tools because I've already gone ahead and provisioned

one.

But there's two things that happen when you click this

register button.

One is it gets registered inside of of the API

portal inside of API Center.

This is going to allow you for discovery.

So your developers might be looking for specific MCP tools

or MCP servers and they're going to, I think I

probably, I need to log in again, but they're going

to be able to go ahead and select the URL

and be able to embed that in their agent.

The other thing that happens is we're going to go

ahead and create those 3 workflows because we selected three

different actions.

So let's look at the create record instance.

And this is going to be a very simple workflow,

but there's some important things that we've done here.

So one, we've gone ahead and constructed A schema for

the request based upon those properties that we selected before.

So the short description, the severity and the assignment group.

Now these are going to then be exposed.

And when the agent goes and connects to the MCP

server, it's going to discover that that data that needs

to be provided.

The next thing that we do is we automatically wire

up those request inputs to the action itself.

So what this does offer you is the ability to

create these workflows, these MCP tools rapidly, even though you

might be very proficient in it, it's something where we're

automating the creation of those.

They're in Logic Apps.

You can go ahead and edit them after the fact.

It's it's completely up to you.

The other thing you can do is, you know, leverage

your existing workflows or create new workflows, and those would

be available as MCP tools as well.

So I'm going to hand it back over to Divya,

where she's actually going to then consume my MCP server

as part of her demo.

All right, so let's go ahead and take a look

at another agent that we have built here.

It's a conversational agent.

It's an agent that helps an organization with its IT

operations process.

So as you can see, I have more than one

agent here and Logic App supports multi different multi agent

patterns.

This is a handoff pattern where I have which starts

with a trigger and then I have a categorization agent

which looks at the incoming request and then based on

the instructions that I've provided it, it categorize it and

sends it either to the onboarding agent if it's related

to device updates or to the compliance agent if it's

related to updating secrets.

And in here I have this section called handoffs.

So this is through this you basically define a natural

language what conditions or what scenarios are under what conditions

and scenarios should an agent do the handoff to another

One South here for example for onboarding agent, we've just

saying that handoff to the onboarding agent when customer has

questions about devices.

So this is how you can easily build these multi

agent orchestrations.

Now the other benefit of a multi agent pattern is

that you can use different models and assign these different

models or provide these different models based on what agents

are trying to do.

And in Logic Apps, you can bring models from Foundry,

but you can also bring models whether if they are

locally deployed or if they are behind a Vnet.

So we have a bring your own model concept here

where you can bring models from anywhere.

And the third option that you have here is to

bring models that are behind API or like AI Gateway.

So you can also bring, let me show here, right?

So I don't have that link open, but you can

also bring models that are hosted behind AI Gateway so

that you can have full governance and you know, visibility

and policies into the token utilization.

Now let's take a look at each of these agents

in more detail.

So I have the compliance agent here and this is

the agent which is using the MCP tool that was

just created and is going to go ahead and create

do incident management via ServiceNow.

Other than that, it also uses a bunch of other

tools in order to get secrets from Key Vault update

secrets.

And there is one other interesting one here which is

the Teams action, which basically takes the human approval before

the secrets are updated.

So here we are using the Teams Connector and we

post an adaptive card to basically get human oversight.

Now let's take a look at our onboarding agent.

So this is an agent that helps employees with device

upgrade and to get the policy around device upgrade it

use it gets that information from a vector store which

is AI search here.

Now when I did the indexing, when I ingested the

policy documents in AI search, I used user permissions or

ACLS to do that.

And now in agent loop I can use the same

ACLS, the same permissions to filter those documents.

So this is again very powerful because now your agent

has access to only the documents that you as a

user has access to.

So it can never go rogue or can never go

and use documents that it should not.

The other thing that I want to show is here

for the sales force connector we are using per user

connection.

So this is how on behalf of authentication, it works

in Logic Apps agent loop where the agent can always

work in the context, in the security context of the

user by using these per user connections.

So let's go ahead and try this workflow.

So here I'm going to go into the chat.

This is a chat that is available out-of-the-box in Logic

Apps.

And so let's go ahead and ask the first question

around help with secret updates.

So here the agent is coming up with information on

what it can do with respect to the secret updates.

So next I'm asking the agent to show me the

list of secrets so I so that I can see

which one needs to be updated.

So here we have all the secrets and you can

see that one of them is near expiry.

So let's go ahead and ask the agent to update

that secret.

So now based on the instructions that we have given

to the agent, the agent is going to go and

go for approval from the human reviewer here.

And that's what we'll we'll see in teams just now.

So here we have we have this approval.

So I'll go ahead and approve the secret update.

And so now the agent is going to go ahead

and make these changes, make the updates and also it's

going to create a ServiceNow incident so that there is

full traceability into what what the agent is doing As

for auditability purposes as well.

So here you can see exactly all the steps that

agent took as well as all the updates that it

did in the systems.

So let's see if I go into my ServiceNow here.

And so this is my secret.

Let me, I think I need to refresh it.

Alright, Yeah, so this is the secret that we just

updated and we now have full auditability, traceability through ServiceNow.

Into what?

Into the actions that agent did.

So now let's go ahead and try another scenario here

because we had multiple agents there.

So there is my chat.

Alright, so I'm going to ask this agent to help

me with some device update as well.

Now in this case, the agent is going to get

the policy document that I was showing you before and

it's going to do that in the context of Maine

because every the organizations may have different policies around who

gets what devices.

Alright, let's try it one more time.

All right, so here I've been in the chat, as

you can see, we can show both text and images.

And now the agent is showing me all the possible

options for me to pick.

So here I'll go ahead and use go with Microsoft

service.

So now what's happening is that the agent is going

to create an order in Salesforce for my request.

So it's trying to do that, but because it wants

me to consent, because it wants to do it in

the context of the signed in user, in the context

of the user who's chatting.

So I'll go ahead and complete this authentication flow.

So that's the power here that the agent is purely

working in the context of the user both in interacting

the systems as well as accessing information inside those systems.

So I'll go ahead and allow this and then the

agent will complete this order.

So in the interest of time, so the order has

been created and it provides us the order number in

sales force.

So in the interest of time, I'm not going to

go to sales force at the moment.

But other thing that I want to show here is

that the same agent that I was showing you, now

you can deploy in Logic Apps these agents to other

surface areas, including Microsoft 365 ecosystem.

So here I have this agent, same agent deployed in

Teams and I can do the same set of interactions

with this agent inside the team.

So this is very powerful as you build these agents

for your organization to make them available within within the

area where all employees are and where they interact and

chat.

So with that, let's move on to our slides.

It's main.

Alright, So what I just showed you is something that

a lot of customers we are working with are doing

and one of them is Vertex.

They are a leading company in, they are a leading

pharmaceutical company and unfortunately they couldn't join us here.

But what they have built is Veda, their own digital

assistant, which helps employees with similar problems where the enterprise

knowledge or the enterprise information that they have is scattered

around different systems and sources.

And the agent they have built is essentially helping to

pull all this information together and generating insights on top

of it in multi multi languages.

So enabling employees across the globe to interact with these

agents and and find results.

And they are using Logic Apps with agent loop where

they have created a multi agent system that helps them

with this process with human oversight by bringing in the

human in the loop that I was just showing you

in the demo before.

And by doing this, they have been able to accelerate

developer productivity in their organization.

They have been able to accelerate what their employees are

doing by enabling them to make faster decisions because the

information is available to them much easily and in a

more accurate and compliant manner.

So they can, they can now manage all their content

at scale and keeping in adherence to the compliance and

the accessibility needs that they have.

So we talked about a lot of features today.

Agent Loop in Logic App standard is available in Georgia,

but we have other SKU's.

We have a consumption SKU which is a low barrier

to entry, pay as you go, multi tenant SKU and

we have Agent Loop available now in Logic Apps consumption

as well in public preview.

Along with that, we in the demo we tried to

cover a lot of other features that we have announced

in public preview at Ignite, including a new designer which

provides you a much streamlined experience in how you develop

and test your applications as well as how you troubleshoot

your applications.

We have support for MCP tools in Agent Loop which

we saw in the demo today.

And using these MCP tools you can use our out

of box MCP servers as well as you can bring

your own custom MCPS.

And regardless of what you're doing, you can still take

advantage of on behalf of authentication with them.

In terms of building these agents who are secured in

in every way, we have of course OBO to access

to interact the systems we talked.

We looked at knowledge retrieval with Acls, which is how

you will retrieve knowledge with user context.

Everything that we showed today was leveraging Microsoft Intra as,

as the security for as the authentication layer for us.

But we also have support for Okta as the identity

provider now.

So you can extend or you can expand it not

just to Microsoft, Microsoft Intra, but other providers as well.

And we have plans to bring more here as well

in terms of models and deployments.

You can bring models from Foundry behind API management as

well as you can bring your own models which can

be local or behind the VNET.

You can deploy these agents to Microsoft Teams or any

other, a 2A based, a 2A based ecosystem.

And finally, what Ken showed you before Foundry control planes.

So these agents participate in the bigger Microsoft AI ecosystem

and you can take advantage of Foundry features for the

agents that are built in Logic Apps as well.

All right.

So just to recap, we showed you a lot today.

Hopefully enjoyed all those demos.

Those were fun to build.

But what we did sort of see today was that

we were able to take sort of existing skill sets,

building logic Apps in a very deterministic way and now

enrich those with agentic capabilities.

So for so for those of you that are already

using logic apps, this becomes a very quick path to

production for your agentic use cases.

And we did hear from a customer, Sideris that has

been able to go ahead and demonstrate that extremely well.

It was super impressive to hear.

How their journey and how quickly they've been able to

go ahead and leverage this capability.

Now there's also some broader themes here too.

We, we saw MCP servers as a way to go

ahead and to connect your enterprise.

And so if you think about how you standardize data

access in your organizations, this is a great way for

you to go ahead and leverage that where you're able

to build these predefined paths to your line of business

systems and then be able to go ahead and govern

them and also be able to make them discoverable so

that you don't have people that are reusing or sorry,

rebuilding those those redundantly.

And then last we did see, you know, this whole

breadth of investments that are are being made.

So we did talk about GA for Logic app's agent

loop in Logic app standard.

So you can go ahead and use that today, but

we're not stopping there.

As you can see, there's a lot of innovation that

are coming down the path as well.

So we do want to leave you with this particular

QR code.

This is going to take you to our Logic Apps

Lab website and you're going to see a whole series

of different curriculum that you can access free of charge.

One is our agent loop in a day where we'll

take you through sort of step by step process of

how you can build an agentic business process around IT

service management using ServiceNow.

But we also have additional use cases and labs as

well.

So that multi agent handoff experience that Divya discussed, that's

in there, connecting to MCP servers, that's in there as

well.

We've got both autonomous and conversational today we talked about

conversational, don't forget about autonomous, leverage our existing large library

of connectors and triggers to sort of kick off a

process, infuse A gentic, reach out to humans as needed.

That's also available as well.

So do go check that out and you know, feel

free to connect with us.

We'd be happy to engage and answer any questions whether

here or after the event as well.

So thank you all for joining us here today.

Thank you.