Hi, and welcome to this short video on what the Agent Framework Toolkit is.
Agent Framework Toolkit is something I, from time to time,
mention in my various other videos,
and I have made some dedicated videos about it before,
but many people don't know what it is, so a small introduction here.
So, Agent Framework Toolkit is, as you see on the screen,
a set of three NuGet packages that sits on top of Agent Framework.
and adds various quality-of-life features.
So, the three main purposes is easier agent creation, easier tool creation,
and out-of-the-box tools.
This is for C Sharp only, so not for Python.
And the best way to explain what it is, is by giving a few examples.
So the first one is these easier agents,
which is done using opinionated factories
against the various providers, OpenAI, Google, Anthropic, and so on.
And, as an example, if we want to make an agent
for plain vanilla Agent Framework
using Azure OpenAI with a GPT-5 Mini,
with low reasoning effort and tool calling middleware,
we would need to write something like this.
We would need to make our client, we would need to make our agent,
and inside our agent we need to set some extra things
in order to set the low reasoning effort.
This is what's called breaking glass,
because it's kind of a very, very low-level overriding object here.
On top of that, in order to set our things,
we need to put our tools inside the chat options
when we want to do it here, so we can't place it like normal.
And we need to use, as builder, use tool calling middleware.build
in order to actually get the tool calling in there as well,
because that's not set on here.
And the tool calling down here is the regular tool call,
in which case, in this case,
we're just printing out what tools we're calling.
So this is the experience using the vanilla system.
If you add the Agent Framework Toolkit on top,
you would be able to do what you see on the screen
with this code instead.
So you would end up making an Azure OpenAI factory for agents,
and you would make an Azure OpenAI agent.
Had it been Google, it would be a Google factory
with a Google agent and so on.
And what I have done is I have made the configuration
of each agent a flat structure.
There's nothing multi-level in any way.
Everything has been put down, so it's very, very easy to do.
So, for example, reasoning effort is directly on some agent options.
Tools is directly there,
and a special raw tool called Details is there
to take care of middleware in just a read manner.
So much less code and much easier code to understand
because it's just a flat model.
And this is supported by all the major providers.
So, for example, here is Antropics Cloud.
We can do exactly the same.
It's just called an Antropic Agent Factory
with an Antropic Agent coming back.
And in here, we have specific Antropic Agent options
because in Antropic, the max output tokens is a mandatory field.
So this one ensures that you remember to set it.
And it, of course, supports their breaking glass features
like budget tokens and so on.
In the same manner, Google, you just make a Google agent
or an AI agent, as you can see here.
More about that later.
And you can set, for example, their thinking level.
And down here, you can see all the different providers
that I support at the moment.
So it should be fairly simple, and if you need one more provider,
it's very easy to extend these.
But you might think, okay, if we're going opinionated,
it might not be able to do everything that Agent Framework can do.
And that's not the case.
There's no limitations despite being opinionated.
So on the connection side, we can still use credentials
instead of API keys.
We can still go to responses API.
We can still set network timeouts.
Or if anything special you do,
there's always a hook-in to the additional underlying options.
And on the agent side, you don't need to make it a Google agent
or an OpenAI agent.
It's just a wrapper around AI agents.
So if you need all the agents to be in AI agents
to pass around to the rest of Agent Framework,
you can do that.
And it supports all the options.
All the common options like instructions, models, tools,
less options like ID, max description, temperature,
all the different providers and factories.
So AI context providers can be set,
the chat history can be set,
client factory and logging factory,
and the services as well.
We can support all the middleware,
but it's been put into being properties on the options
instead of down as builder,
so it's easier to work with.
And then there's, of course, the OpenAI-specific features
like client type, reasoning effort, reasoning summary,
service tier, and so on.
And finally, I put in a bunch of debugging features,
so you can, with one line here,
add the raw HTTP tool client,
so you can begin to see the raw JSONs being sent
to the LLM and from the LLM.
And if, again, there's anything I'm missing,
there's an option to provide extra things
for chat client agent options.
So, again, no limitations at all.
Similarly, we also have our tool factory,
which makes tools easier to create.
So, this reintroduces something that Semantic Kernel had
in that we can add attributes onto our classes
and the various methods we want with an AI tool attribute,
where we give the tool name and the description.
And if we do that, we can simply use this AI tools factory
to, say, get tools from the raw class
or the instance if you want to.
You can, of course, do this with normal reflection.
I've just done the reflection part for you.
Similar, it has hooks into MCP servers,
so the factory can just turn
an MCP remote from just a URL into tools.
You can, of course, specify header properties and so on if need be.
And then there's local MCP servers that is also supported.
Finally, I have my own implementation of agent skills
that came a little before agent framework put it in.
And it has its variety.
It turns it into tools instead of using the AI context provider.
Besides being able to take your own tools and define them easily,
I also put in a set of common out-of-the-box tools.
So, there's time tools, so you can tell your agent
exactly what the time of day it is,
either in UTC or in local time.
There's integration into some weather tools
for real open weather map.
You just need a read API key from them,
and then you have full access to weather around the world.
There's file system tools, so you can create
and get files and folders on the system.
And there's guardrails built into them,
so you can set what exactly they are allowed to use,
of which folders and so on.
And by the way, these tools are completely out of the box,
but you need to define if you want to use them.
It's not like if you use agent framework tool kit
that you suddenly get full access to your file systems.
That's on your definition of if you want to use them or not.
There's website tools for getting content off a page,
screen-scraping.
There's HTTP client tools, so you can actually
call APIs and stuff like that,
if you desire to do so, and it can, again,
have guardrails in on what different endpoints
you are allowed to use.
And finally, there's a little email tool
where you can send SMTP emails.
So just tools that you sometimes need
and don't want to write yourself.
So they have been written for you
with lots of configuration options into every single tool.
So that's everything. There is more.
There's various quality-of-life extension methods
and bedding factories, but we don't want to go into this.
Instead, I want you to go in and check out the link.
It goes to the repo, which has a bunch of readmes
about what every feature works and a wiki about it,
and, of course, access to the NuGet packages
that you can get for free and just put on top
with no limitations.
So that's everything.
See you in the next one.