Microsoft Agent Framework with Shawn Henry

[00:00:00] - [Scott Sauber]
Welcome everybody to our first episode of agent driven development. My name's Scott Sauber and I'm one of the hosts.

[00:00:06] - [Spencer Schneidenbach]
I'm Spencer Schneidenbach and we're here with Shawn Henry, one of the well, the program manager for Microsoft agent framework.

[00:00:13] - [Shawn Henry]
That's right. Yeah. Nice to be here.

[00:00:14] - [Spencer Schneidenbach]
Why don't you start by telling us about your Microsoft journey? I think you've worked for the company about twenty years?

[00:00:19] - [Shawn Henry]
Yeah. Almost twenty years now. It's been a long time, my whole career at at Microsoft. I started guess my first big project was working on Windows Phone, if those of you remember that. Probably most people are getting aging out of that, but that was really kind of my formative experience at Microsoft, really shipping a product that, you know, people loved but, you know, didn't didn't really make it in in market.

[00:00:43] - [Shawn Henry]
And then from there, I worked on the kinda Windows developer platform for quite a while and then moved over into Azure and in the Microsoft March world, incubated and started a product called Azure Communication Services, which was, you know, a service for connecting, sending SMS messages and phone calls and video calls and and and all those things, using the infrastructure behind Teams to kinda build a white label version of Teams. And then, you know, a few years ago, like a lot of us, I had my, like, chat GPT moment Mhmm. Where I said, okay. This is this is it. This is this is gonna be an exciting thing.

[00:01:17] - [Shawn Henry]
So I moved over to the office of the CTO where we incubated I joined the semantic kernel team. We incubated that. And then about a year ago, joined joined the foundry team and built Microsoft Agent Framework by bringing together Autogen, which is another one of our libraries for building AI and AI agents in Symantec Kernel into the Microsoft Agent Framework.

[00:01:40] - [Spencer Schneidenbach]
Nice. And so talk about where Symantec Kernel started. Like, I mean, Microsoft Agent Framework is Microsoft's investment. We're almost at we are almost to we're in the release candidate phase, so it's getting close. Right?

[00:01:53] - [Shawn Henry]
Yeah. I mean, maybe by the time folks are listening to this, we'll we'll be at our v one o release. At the time of recording, we're probably a few days away from that. But early April, very early April twenty twenty six, we should we should be at that one o place. And it's been, you know, this tremendous journey.

[00:02:09] - [Shawn Henry]
We only released it for the first time in October. So it's been less than six months where we've gone from our public preview of agent framework to, v one o. And a lot of that is because we've been able to build on top of a lot a lot of the great work from Symantec and from Autogen, which is our multi agent, framework for Microsoft Research.

[00:02:29] - [Scott Sauber]
So why don't we take a step back and talk about, like, what is Microsoft Agent Framework? Like, why would people use it? What problems does it solve?

[00:02:36] - [Shawn Henry]
Yeah. You know, a good way to start, you know, you mentioned, you know, Symantec Kernel and some of the history there. Symantec Kernel, someone just told me this morning that it was released three years ago today Wow. Which, you know, in AI years is probably, like, fifty years. At least.

[00:02:50] - [Shawn Henry]
And, you know, it started before I joined the team. I wasn't there for the first release. But, really, its its its goal was to take all the AI services and capabilities that were out there and help you build AI applications. And actually, you know, they were I always joke that, like, Symantec Kernel was building agents before they were cool. You know, it had the concept before models could handle things like tools.

[00:03:16] - [Shawn Henry]
Before models could do any sort of planning, they had a concept of planners. You know, before before models had any concept of of loops and and iterating on stuff, it had that stuff built in. And so that was kind of the genesis of Symantec Kernel around kind of agents before agents were a thing and just how do we connect all these AI services and memory services. And then Autogen came out of, Microsoft Research, and it was really focused on how can other how can agents collaborate together? If if you have agents that specialize in different tasks, can they work with other agents?

[00:03:49] - [Shawn Henry]
What happens when you give agents different models, different capabilities? Can they solve problems better? And it turned out they did. And so those two teams fused together into we we realized we're kinda building very similar things. So something that rarely happens at big corporations is we realized we were building the same thing.

[00:04:08] - [Shawn Henry]
So we decided to team up and build one great thing instead of two good things. And that's where Microsoft Agent Framework came in. But, really, it's the same it's the same goal. It's a library to help you build your AI and agent applications. So it's got best practices and connectors and patterns and components that you can use to build AI applications and agents.

[00:04:30] - [Spencer Schneidenbach]
Love that. So let's just just for the listener's point of view because I work in the .net space and a lot of dot net people have not used anything. So just to break things down a little bit, an agent really starts the basic building block of an agent is the prompt, the model, and the tools that it has. Correct?

[00:04:47] - [Shawn Henry]
That's right. I would say tools are the thing that make agents agents. That's That's what makes them magic. Right. It gives them the ability to do something.

[00:04:54] - [Spencer Schneidenbach]
The the one thing that I think Symantec Kernel did really good was that it provided a really solid and easy programming model for being able to define tools. It could reach out like c functions or Python functions that could reach out to a database. So or do really do whatever pro like, literally do anything within an application that you you would have it do. It could schedule if you're if you're a scheduling app, it could schedule something and give and basically, the agent would be defined such that you would create a bridge between I'm gonna u I'm gonna connect this agent to an LLM, and as long as it knows the tool that it needs to call, it can invoke my own functions.

[00:05:28] - [Shawn Henry]
Yeah. I mean, think the way I think of it is, you know, you're already building your applications, and they have methods and functions and classes and all those things. And what if you could just tell an LLM about those? And so we made it very easy in semantic kernel and and and agent framework to just annotate your you know, you decorate your methods in in c sharp, and and then you tell your agent about them. So you have like you said, you could have a method that accesses a database.

[00:05:54] - [Shawn Henry]
You can have a method that calls a web service. You can have all the methods that you're already building, all these functions you're already building. You just tag them with we annotate them. We'll use in dot net, we'll use reflection. We'll figure out how to call that method, and then we'll tell the LLM how to use it.

[00:06:08] - [Spencer Schneidenbach]
Yes.

[00:06:08] - [Shawn Henry]
So it really allows the LLM to basically use all of the code that you've already built to do things. And that's what kind of tools and agents, that's what they're all about.

[00:06:18] - [Scott Sauber]
So, I'm curious. So, there's semantic kernel and there's auto gen. So, let's say somebody's on one of those things now. What's the migration story look like for getting to Microsoft agent framework?

[00:06:29] - [Shawn Henry]
Yeah. So, if you're on either of those, so Symantec Kernel was kind of a little bit more formally supported by Microsoft. We did have Microsoft Unified Support was supporting it, and we did make a lot of promises in Symantec Kernel around breaking changes and and support. Autogen was much more of a research project. Also, for, you know, dot net developers, it was a lot more Python focused.

[00:06:48] - [Shawn Henry]
They did have a dot net version. But, definitely, most dot net developers were were into semantic kernel. And then in terms of migrating, you know, because it's the same team, in a lot of cases, the code base moved over from semantic kernel to agent framework. In fact, internally, agent framework was called semantic kernel v two for quite a while until we kinda did a rebrand around agents. And and there's this thing called a kernel object in some a semantic kernel, which is no longer there in agent frameworks.

[00:07:14] - [Shawn Henry]
So we're like, doesn't make sense to call it the the not the semantic not kernel. Mhmm. So we tied it on a new name. So in general, the patterns and and practices and and kind of architecture is very similar between semantic kernel and agent framework. And then what we've done, obviously, we have migration guides.

[00:07:32] - [Shawn Henry]
But we also have some tooling built into Versus Code, uses GitHub Copilot to actually do the migration from semantic kernel to Autogen. And, you know, one of the interesting things is, you know, the question you ask is the number one question people obviously ask. It's like, oh, there's something new. I've been using this previous thing. Like, what is it gonna take for me to migrate?

[00:07:50] - [Shawn Henry]
I have been very, very pleasantly surprised. Like, literally, universally, the feedback I've gotten from folks using our migration tools is that it was completely painless, and they were able to do it. Nice. And I think that's because we're in a golden age of, like, being able to migrate right now with things like GitHub Copilot. It's never been easier to migrate your code from one thing to another because you ask GitHub Copilot to do it.

[00:08:13] - [Shawn Henry]
In agent mode, it does it. You can see the changes it make. You can review them and and and kinda move forward. So generally speaking, that's been a pretty, painless process, I think, for most folks, and they've been pretty happy.

[00:08:24] - [Spencer Schneidenbach]
At what point in the Symantec Kernel journey? Because I came to the last year's MVP summit, that's where I met you, and I was very invested in Symantec Kernel, and all my customers were too. In fact, when I first started using it two years ago, it was one of my bosses came to me and said, is Microsoft gonna take Symantec Kernel seriously? And all the signals that I got were, yes, they are. I'm I actually think that the the abstractions within agent framework are really good, and I like the library in general.

[00:08:51] - [Spencer Schneidenbach]
Talk about the moment where were you and your team, and I assume that you were probably heavily involved in this decision. I can't pretend that I know how Microsoft works, but I assume that there was a point where like, what is the feedback that we're getting from our customers and our users of this application that we're like, okay, we actually need a new abstraction. Then that where did where did agent framework come from that?

[00:09:12] - [Shawn Henry]
Yeah. I think, you know, a lot of that actually came from Autogen. You know, we really actually liked a lot of the again, because because Semantic Kernel kinda predated the concept of agents. You know, we made some decisions, which I think were probably good decisions architecturally at the time, but the industry momentum was around this concept of agents and how you attach instead of kind of this kernel object, which was kind of this god object that floated around, actually having this kind of embodiment of an agent with its own life cycle associated with it. So it really was like a pragmatic thing of this is where the industry is going.

[00:09:46] - [Shawn Henry]
If we wanna be able to speak the same language as everybody else across .net, across Python, across JavaScript and TypeScript, and all the other libraries and work and research that's being done around AI systems, we really needed to talk agents. Now I think we've been able to do a really nice job while still making it feel very natural for .netdevelopers by relying heavily on things like dependency injection and factory methods and things like that. Definitely, the balance of of of of the feedback that I get is much more around Python developers being like, this doesn't feel very Pythonic sometimes. And I have to talk to them. It's like, well, have you heard about dependency injection?

[00:10:25] - [Shawn Henry]
It's actually really cool, and maybe you should be using it on the Python side a little bit more than on the dot net side. So that that's really where that came from is is just really trying to align so we're all speaking the same language across industry.

[00:10:38] - [Spencer Schneidenbach]
I think I'm at getting a Python developer to try to use dependency injection. It's like getting a dot net developer to stop declaring everything as an interface.

[00:10:45] - [Shawn Henry]
Yeah. I think so. But, you know, the the point there is is that, you know, one of our our main goals with with agent framework and was with Symantec Kernel is, you know, how do we get, these agent systems at scale? And that's really where things like dot net come in as you know, I would say probably dot net and Java are, like, the two languages or systems out there that have really been proven to be able to deploy enterprise system services really at scale. Mhmm.

[00:11:17] - [Shawn Henry]
And and so being able to actually you know, those those practices and techniques and all the things we've learned in the dot net world over the last, whatever, twenty five years, I think are very applicable to AI systems. And I I I feel like the Python world is now relearning those as there's kinda scale out AI systems for sure.

[00:11:36] - [Scott Sauber]
What do you think is like the most underutilized feature of Microsoft agent framework that people might not think of or take advantage of as much as maybe they should?

[00:11:46] - [Shawn Henry]
That's a really good question. I mean, there's there's so many there's so many good features. I think one that should come very naturally to .netdevelopers is our concept of middleware. And, really, that's just our extensibility hooks into into the life cycle of the agent. But, of course, those are incredibly powerful and uses exactly the same middleware patterns that you're familiar with already in .net.

[00:12:10] - [Shawn Henry]
And they allow you to just plug in everywhere into that agent life cycle. So you can do things like you can you can inspect and modify a tools call before it gets made by the agent, or you can do your responsible AI check, your content safety check before that data goes to the the service. Or afterwards, you can send it off to Purview. Maybe you have some, you know, policy protections on top of that. That's one that, like, always seems to seems to, like, bail me out when I'm building applications.

[00:12:35] - [Shawn Henry]
Like, oh, I just need to build a piece of middleware here to to to do this.

[00:12:38] - [Spencer Schneidenbach]
Yeah. The for me, the the the analog and semantic kernel was filters and easily Everything. Easy exactly. And Easily, the the place where I can put in My validation was probably the biggest lesson that I've learned was the the use of filters are so powerful, so I agree that that middleware abstraction was absolutely necessary.

[00:12:59] - [Shawn Henry]
The other one of the basic layer, I think, you know, you mentioned we were talking about just annotating functions with with tools. Being able to use and this this was in semantic kernel as well. Being able to take the output of your LLM as structured data and then have that serialized directly into an object, I feel, is always incredibly powerful, where I can basically use my objects and my data structures that I've already created in my dot net application and have those get serialized and deserialized into the LLM for free. And now my agent my my language model is not speaking English. It's speaking the object model of my application.

[00:13:37] - [Shawn Henry]
I find that incredibly powerful as well.

[00:13:40] - [Spencer Schneidenbach]
Did you look at so when I'll have two questions, really, about the the decisions that you made to target the ecosystems that you did, which is dot net and Python. What other did you look at other agent frameworks that existed out in the market like Vercel's AI framework or even Claude's or OpenAI's agent framework? Also very good, very very tight abstractions and they all choose to target different things. OpenAI targets Python and TypeScript. What did you learn from those other agentic frameworks that kinda went into agent framework?

[00:14:12] - [Spencer Schneidenbach]
And why did you choose to target the two ecosystems that you did?

[00:14:15] - [Shawn Henry]
I mean, the second part of that question first is those were the two most important ecosystems to us at Microsoft. And the way I think of it is is one is you know, really, we are, in a lot of ways, the only game in town on the dot net side. Mhmm. And so we felt it was very important for our dot net community to have a really good AI and agent experience. So we do work a lot with the dot net team with their Microsoft, extensions dot AI abstractions.

[00:14:41] - [Shawn Henry]
We're built on top of that. But we definitely felt that, making sure that it was a great experience for dot net developers, as good an experience as they could get anywhere else, was very, very important for us on the dot net side. And then the Python side is is really that's where a lot of the leading edge innovation on the AI side is happening right now. That's what, a lot of the research orgs that are building the models, that's what they speak. That's what they use.

[00:15:09] - [Shawn Henry]
That's what the Autogen team have been using to do their research as well, and build their their framework. So those were kind of the natural two. That is Python is also the most common language used with, with Microsoft Foundry and and AIs and our AI services with with dot net and c sharp being a close second. We're we're not opposed to doing other languages. We've had a few community projects here and there that have started doing TypeScript and, and Go actually in Java.

[00:15:37] - [Shawn Henry]
And it's definitely on our radar to do that, and we're thinking of kind of inventive ways to do that without having to, you know, do a big lift and shift of all the code code we've built already.

[00:15:46] - [Spencer Schneidenbach]
Hey, Copilot. Transfer this framework. Re make this framework in TypeScript. Don't make mistakes.

[00:15:52] - [Shawn Henry]
You laugh, but we're well, that's that's one of the options on the table.

[00:15:55] - [Spencer Schneidenbach]
No. I imagine that it is.

[00:15:56] - [Shawn Henry]
You know, if you can if you can build your tests and your samples and, you know, have a way where you can be outcome driven by that Yeah. We can actually have a lot of success building.

[00:16:05] - [Spencer Schneidenbach]
Oh, yeah. Start with the end in mind. But from an AI agent perspective from a coding agent perspective, that certainly is a very powerful pattern. Let's talk a little bit about what are the things that I think was interesting as I was getting into AI and as I was becoming an AgenTic developer and not just using AgenTic coding tools, but building I built and delivered several projects using semantic kernel as a framework. And I think that one of the biggest problems that I had was was bridging the gap.

[00:16:32] - [Spencer Schneidenbach]
And what I mean by that is I'd have a dot net developer, and I spent a lot of time on optimal tool design, I made a lot of time on on how do you prompt well, how do you compose your tools so that the LLM could not get confused. And I found that the programming model for semantic kernel really encouraged, like, dot net developers were just like, let's put all the tools on the plugin, which was a single for the for the listeners, was a single class with all of your tools on it. And then they would just add more and more, not recognizing that you're actually bloating your context window and you're actually making your LLM worse. So talk about some of the design decisions that went into agent framework that maybe helped bridge that gap where they were they were defining and building agents in agent framework. Did you did from a product perspective, what effort and what thought went into?

[00:17:23] - [Spencer Schneidenbach]
How do we make sure that we're not letting, like, people giving giving them basically a 100 foot guns to shoot themselves in the foot with?

[00:17:30] - [Shawn Henry]
Yeah. I you know, that's that's an area that we're kinda constantly working on and developing. I think, you know, that context and, ultimately, a lot of that is is this space called context engineering, which is, you know, a a nascent, pretty new space, but becoming very very, very powerful in terms of how we can make agents work better. And, you know, even with the models being able to handle these larger and longer context windows, which effectively being able to give them more data to chew on, they still work better the the the more constricted the the the task you give them, the the more, details and, specific instructions you give them, the better they work. So one of them, for example, with, you mentioned tools, very common, especially with the advent of m c MCP, which kinda came in, over the last year or so.

[00:18:22] - [Shawn Henry]
It's very easy to give your agent lots and lots of tools. Git the GitHub MCP server itself has hundreds of tools associated with it. And, you can even see this today if you use something like GitHub Copilot. And as soon as you enable the GitHub MCP, suddenly, starts giving you warnings like you've got too many tools. I may not be able to perform as well.

[00:18:40] - [Shawn Henry]
And we definitely see that when you're building agents with with semantic kernel agent framework as well. And so we have we have some patterns and and samples for that one specifically. You can take your tools, and you can actually put them in, like, a lightweight vector database and do, like, a semantic search over them. And so you give your agent you basically search, and you say, these are maybe the top 10 tools that you could use for this particular task. The other one that we've kinda recently added is a lot of chat compaction strategies.

[00:19:08] - [Shawn Henry]
So especially as these new models are able to run and pay a lot more attention longer so these are things like Claude Claude Sonnet and Opus three seven and the the GPT five three and five four models. We're able to pay attention a lot longer. And what ends up happening is that generates a very, very long chat history, some of which is not useful at all. And you can blow up your context window that way as well. So we've added things like chat compaction strategies that can take those and either pull out some of the metadata, like some of the tools calls that you may not actually need, be able to actually apply an LLM to that to do a summary of that conversation, pull out all the relevant information.

[00:19:48] - [Shawn Henry]
And then, of course, the other piece you can do is there's the advent of a lot of these memory libraries, things like like MEM zero and, Redist has one. We have one built into Foundry as well. When I was recently talking to the Neo four j guys, they have a really nice one, as well that will automatically synthesize your chat history into relevant relevant memories for for your agent.

[00:20:10] - [Scott Sauber]
So say I'm a developer listening to this and I'm like, okay. This all really sounds cool, but, like, my product owner really hasn't given me any, like, stories to build that makes sense for this or business analyst or whatever. Can you talk about a situation like, hey. I think a lot of apps could benefit from this type of feature that can leverage Microsoft Agent Framework.

[00:20:29] - [Shawn Henry]
Yeah. I mean, I think you need to talk to your product owner and and and get them get them convinced, get them into the the twenty sixty the twenty twenty sixes, I guess. I'd be very surprised if if there's anyone who doesn't have that at least on the back of their mind right now. But I think your point is valid. It's like, how do you prove the value?

[00:20:46] - [Shawn Henry]
How do you prove the return on investment? There's a couple of things that I can think of. You know, one is that I've seen that is kind of doesn't impact the product directly, but you can show value is by adding some some of your automated testing, like adding agents into that, having agents test your your product. You you can start annotating all your methods and then have your agents use them and and kind of recompose things and validate them that way. I think the other one is to really just try stuff out and experiment with it.

[00:21:16] - [Shawn Henry]
You know, honestly, you can you can you can put your code base something like GitHub Copilot, and you can ask it, like, where can I use an agent to build this? Anywhere where you're doing today any sort of workflow style automation, I wouldn't necessarily say replace that with an agent if you've got working code that's working. But, typically, what we'll see is that someone will have built a workflow that does maybe 80% of of whatever the scenario is, like, you know, employee onboarding reports or or analyzing some data. And then you have some human in the loop, some human intervention happening in there. And those are places where those are ripe for plugging in an agent to try and close those gaps.

[00:21:57] - [Shawn Henry]
If you're building a workflow from the beginning, you can make it completely agentic from the beginning. But if you already have an existing workflow and you're looking at, like, how do I add AI to it, that can be a good place to start is look at the places where you're having humans actually have to intervene and see if you can use, use AI or an agent there.

[00:22:13] - [Scott Sauber]
That reminds me of I've always said like, anytime there's a import from Excel or download to Excel, that is almost always a theme where something else is happening in the workflow that's outside of the application that you're doing. So, there is usually a story behind why people want those features.

[00:22:31] - [Spencer Schneidenbach]
You mean that you mean that there's still opportunities in this in our industry to replace like, you know, Martha in accounting's 10 spreadsheet system with some kind of centralized

[00:22:39] - [Scott Sauber]
Oh yeah, with VBA macro that was written fifteen years ago that nobody knows? Yeah, exactly. How it works.

[00:22:45] - [Spencer Schneidenbach]
Talk about so Microsoft is famous for dogfooding their products. Are there any major products you could talk about for that Microsoft are building with agent framework?

[00:22:54] - [Shawn Henry]
Yeah. So, you know, there's there's a lineage of frameworks at Microsoft. They kind of all date back. A lot of them date back to the original semantic kernel. There's kind of forks that are used in, you know, other places like like like in m three sixty five Copilot and and elsewhere in kind of the office world.

[00:23:14] - [Shawn Henry]
You know, a lot of it is when you know, if your product is big enough, they end up effectively forking what we built, and they have their own team kinda kinda working on it. So that often happens for a lot of the larger projects at Microsoft. But for the medium sized ones, you know, it's the same thing that applies to most people is is is a lot of times they start off, you know, building their AI project. And they're like, oh, well, we we need an orchestrator. That should be pretty easy to build.

[00:23:39] - [Shawn Henry]
I'll just kinda connect. I'll build this kinda agent abstraction. I'll connect them together. And then they find out pretty quickly that now they're in the business of building an AI orchestrator, and they're like, okay. Well, let's go use something like agent framework.

[00:23:50] - [Shawn Henry]
You know, I was talking to a a number of teams internally that are using it for especially, like, the workflow capabilities with an agent framework where they're able to, take a lot of their existing workflow capabilities and convert that into an agent framework workflow and then deploy that and scale that with them internally. The neatest one I saw recently was Planner was using, was using, actually, Autogen, and we were moving them to to agent framework. Kinda take their plan that they've built and then be able to build, like, a status report on top of it. It was like a multi agent system that could go in and build that. I thought that one was really neat how that was built.

[00:24:29] - [Spencer Schneidenbach]
Any other creative projects from Microsoft's that especially if they've even if they've just started with agent framework or they went from semantic kernel to agent framework. What's their early feedback been, and what have they been delivering?

[00:24:41] - [Shawn Henry]
You know, another one I think that's interesting that we use we actually use on the team ourselves is we have our own workflow for for handling bug reports and pull requests and things like that on the GitHub repo for agent framework. So very similar to things that, you know, GitHub Copilot does, where we're able to build it into our own internal workflow and be able to, you know, look at bugs, have them review PRs, with our processes that are internal, have it work and, like, ping the right folks on Teams if they need to look at stuff, make suggestions for changes. And then one of the huge ones is it helps us a lot. We our our doc system at Microsoft, it's kinda separate and allows us to integrate into that every time we make a code change. We can have an agent go and look at the docs and decide, oh, this doc needs to be updated.

[00:25:26] - [Shawn Henry]
Here's a suggestion of how to fix it. We can go in and be like, okay. This looks good. Make some modifications, some human modifications. So it really helps take a lot of the the toil almost out of software development.

[00:25:38] - [Shawn Henry]
Like, I think everybody recognizes, say, how important good docs are, but nobody wants to spend the time to do them. So be able to have an agent that helps you kinda make suggestions, and then, and then you can approve them or modify them or or fix them yourself really makes it a kind of a much more enjoyable experience to, you know, add features and and and to document them and build samples.

[00:26:01] - [Spencer Schneidenbach]
So what you're saying is developers, if they find a boring part of their job, they could use agent framework to automate at least a little bit of it.

[00:26:07] - [Shawn Henry]
Of course. Yeah.

[00:26:08] - [Scott Sauber]
Yeah. Likes writing docs.

[00:26:11] - [Spencer Schneidenbach]
Oh, right. Exactly. Yeah. Nobody Documentation never goes to rot at our customers. So,

[00:26:17] - [Scott Sauber]
it sounds like migrating to agent framework if you're on semantic kernel is very easy. I'm assuming there's some people are like, well, how do I know that Microsoft's not just gonna change their mind in a year or two again? Anything you wanna say for anybody who's worried about something like that?

[00:26:32] - [Shawn Henry]
Yeah. I mean, I think self is moving so fast, like, no one's gonna be able we we may be in a world where we have, like, artificial general intelligence in a year and then everything gets turned out the window. But, certainly, the goal with Microsoft Framework was a response to that feedback. You know, the the feedback that we were hearing is, you know, you're building too many libraries. I don't know which one to use.

[00:26:52] - [Shawn Henry]
I don't know which ones are gonna be supported long term. So our goal with agent framework was to consolidate that in one place and have one library, that, you know, is the place going forward for all developers to, to build their AI applications. What I suspect you will see is is is you'll see things kinda develop, elsewhere in other parts of of, Microsoft, and then we'll integrate with them. So one example is we did a fair bit of integration with Copod Studio, for example. So Copod Studio is kind of the no code agent building tool on the Microsoft three sixty five side.

[00:27:31] - [Shawn Henry]
And so we built the ability. You could build agents in there visually. We weren't gonna build a visual tool on agent framework. You can build them visually there, but then you can integrate them with your broader agent framework, solution. So you can have a multi agent solution where some of those agents are built with agent framework.

[00:27:47] - [Shawn Henry]
Some of those agents are built with Copilot Studio, and they can interact with each other using using agent framework. So become this, like, connector between these different agent services. I think we'll see that as well. We just recently did integration with GitHub Copilot CLI and Cloud Code, which kinda provide their own opinionated agents inside, like copilot.exe. And so you can actually build your agents or call into agents within Copilot, GitHub Copilot, and have that be part of your larger agent orchestration.

[00:28:17] - [Spencer Schneidenbach]
Talk about the investment that you've made in the tooling. I think that the the one thing that was and I I don't recall really using much in the way of semantic kernels, like, if there was tooling. I think they had, a very small Versus Code plug in. Talk about, as you're moving into agent framework, the tooling that you provide. Because you could provide a programming language all day, right?

[00:28:37] - [Spencer Schneidenbach]
But if it doesn't have good tooling in the IDEs or even just providing back pressure to agents, it's not very it's it's not as useful as a thing that it is. So talk about your investment in the in like the Versus a lot of the Versus Code extension that you're

[00:28:51] - [Shawn Henry]
So, I mean, similar to the last question. I mean, that's one of the great things about becoming the thing, the way to build agents is now the other teams at Microsoft that are responsible for different things like evangelism or tools or or or UI integrations. Now they know the one thing that they can build against instead of being in wait and see. So, the Angel Framework team, you know, we don't build the extensions in Versus in Versus Code, but we work very closely with the team that that does. And, those are part of the AI, the AI toolkit, that's, that everyone, if they're using AI, no matter what language you're using, you should definitely install that if you're using Versus Code for, for building your applications.

[00:29:30] - [Shawn Henry]
And they were able to then, you know, very deeply integrate with agent framework. So for example, when you install that, when you install the the AI extension, it also installs some rules into GitHub Copilot so that when you ask it to build an agent, it knows how to use agent framework. It knows all the latest best practices. It can do some really neat things too. Like, if you're logged into Foundry, it'll actually be able to pull your keys and be able to put those into into your environment variables or project settings as you build your application.

[00:30:01] - [Shawn Henry]
So you're not always hunting around. It's like, oh, does the URL do I need the slash or not the slash? Or how many parts of it do I need? It'll figure all that out for you and put that into your project settings. And that's worked out very well as well.

[00:30:14] - [Shawn Henry]
And then from there, you can also visualize your agent systems. Again, we specialize in multi agents. And so being able to see how one agent is talking to another, what your workflow looks like, being able to see your logs and your traces in a visual tool as you're building locally, I think, is incredibly powerful. And then the goal with things like AI Toolkit is then to take the next step, which is to make it very easy now to deploy it into Azure. So once you've built your your agent application locally, you've debugged it, you've got it working the way you want, be able to deploy those agents directly into Foundry, or into Azure so that you can you can then integrate them with the rest of your system from up there, and you can observe them and manage them from Foundry.

[00:30:56] - [Scott Sauber]
Anything you wanna talk about what's coming next in agent framework

[00:31:00] - [Spencer Schneidenbach]
besides GA?

[00:31:01] - [Shawn Henry]
I mean, GA GA is definitely the most important thing, and that's what, you know, the team is is is definitely heads down on. We recognize how important that is, to get to that version, the version one o, get some stability, so that people can rely and go to scale. And that's certainly the thing that we measure our success most in agent framework on, you know, how we can get people to scale with their applications, you know, with Azure Azure and and and AI foundry services. But after that, I think, you know, everyone's very interested in clause. Think those things like OpenClaw, NanoClaw, all these things are available.

[00:31:34] - [Shawn Henry]
You know, incredibly interesting to see those being used. Obviously, very scary to think about what those those look like in an enterprise environment. But I see that as a challenge and something that we should take up on on the agent framework team is is how can you build these clause like systems in a way that you can scale and manage, and observe and have resiliency around an enterprise environment. So to that end, you know, I mentioned the integration with with with Copilot SDK, as well as work that we've done, around, kind of these longer context windows and compaction, actually providing tools in a a a pattern for doing authorization for when, you know, your agent does need to access the file system or does need to does need to execute in, execute, code, run code, or run shell commands, within its environment. So that's kind of a lot of the building blocks needed.

[00:32:30] - [Shawn Henry]
And then I think we'll take the next step of how do we tie those all together so that you can build these kinda claw like systems that, can can can, you know, take signal from you or from other places and then work on that task in until it's completed. I think that's a very interesting space and could be very powerful in the enterprise once we kind of figure out how to do it in a sane way.

[00:32:50] - [Scott Sauber]
You just made a lot of security people very

[00:32:52] - [Spencer Schneidenbach]
happy. Yeah. They're not worried about their jobs right now. Yeah.

[00:32:56] - [Scott Sauber]
Yeah. Alright. As we wrap up here, any last words? Anything else you wanna leave people with?

[00:33:01] - [Shawn Henry]
Give it a try. Give me Microphone Agent Framework a try. You can find us on GitHub. Just type agent framework into in into the search. I think aka.ms/agent-framework will also take you there.

[00:33:14] - [Shawn Henry]
A couple other things I'll plug. We do a weekly office hours every Wednesday at 9AM Pacific. The engineering team from agent framework is there. Great place to join if you have any questions or if you just wanna hear or see the latest of what the team is working on. We also have a very active Discord that folks can can join, and all that is linked from the GitHub repo.

[00:33:34] - [Shawn Henry]
So that's kind of the best place to start.

[00:33:35] - [Spencer Schneidenbach]
You can pull it up. Well, thank you, Shawn. Really it's really been good. I think that agent framework is really good. A really good agent abstraction framework.

[00:33:43] - [Spencer Schneidenbach]
So vouch from this customer at the very least.

[00:33:46] - [Shawn Henry]
Great. I love to hear it. Yeah. And the more we can spread the word, the better.

[00:33:49] - [Scott Sauber]
Thanks Thanks, Shawn.