Today I'm having a look at OpenAI's new

agent builder. This was released a few

weeks ago. It's pretty cool. You can

create some really interesting agents.

I've been messing around with it, seeing

what it's capable of and building a few

agents of my own. I want to give you

kind of a quick demo/ tutorial and then

share with you my thoughts because while

it is really interesting, there are a

lot of limitations that I don't see many

people talking about. Anyways, let's

dive into it and have a look at the

agent builder. So, this is the interface

for the new agent builder. Looks like

this. I just have an example agent that

I was working on previously up on screen

here. And you can see that you have all

of these different blocks kind of like

Scratch or like a drag and drop editor.

And you can connect these together kind

of just by dragging them through. You

can click in, you can view all of the

different options. And they have things

like MCP connectors where you can

connect directly to, you know, Google

Drive or Shopify or you can bring in

your own MCP server like this. Now,

while that's pretty cool, it is fairly

limited in terms of the external

connections right now. But regardless,

you can still create some pretty

interesting flows like the one that I

have right here. Now, I'm going to get

into this flow. I'm going to show you an

example of an agent that I've built and

kind of how to do that and how to

connect the different blocks. However, I

want to quickly go over a lot of the

things that OpenAI has released recently

because it wasn't just this agent

builder. Now, this is the original

announcement back on October 6, about a

month from when I'm filming this video.

And you can see that they actually were

introducing agent kit. Now, I guess

that's what they're calling all of these

kind of tools combined together. So, for

example, that includes the agent

builder, the connector registry, and

then chatkit, which is kind of I guess

like an add-on to the agent builder,

which allows you to use these

interesting widgets. So, you can have

like forms, displays, list views,

whatever. You can actually make your own

widgets. So, you can display the data

coming back from your agent in kind of a

prettier, you know, more usable way.

Now, what's worth noting here is that

before this release, OpenAI had the

responses API as well as the agents SDK,

which was a more developer kind of

centric way of building AI agents and

communicating with OpenAI. You've

probably used it or seen it used before,

and this is just adding tools that make

it easier to build those agents. Now,

with that said, there's a lot of moving

pieces here. There's a lot of tools that

OpenAI now has. And to be honest, I'm

pretty confused by all of the ones that

they have and how they work together. A

lot of their documentation is currently

not working or not up to date. I read

through a lot of it before preparing for

this video. So, while all of this stuff

is cool, it is still very early days and

I hope that they fix it soon because

there's a lot of stuff I wanted to do

that I just couldn't figure out how to

do in a relatively short period of time

because of how confusing some of these

tools are. Anyways, that's kind of the

new release. I'll also just quickly show

you that chatkit is kind of this more

developer focused, you know, add-on to

this agent builder. So, while you can

build your custom agent and you can mess

around with it in the browser and you

don't really need to know how to code,

if you want to use something like

Chatkit and have these really fancy

widgets, which I'll show you in a

second, you do need to have a little bit

of developer experience here and embed

these directly in your front end with

some kind of flow like this. Again, I'll

have a look at that in a second, but

just letting you know that while it

seems cool with the agent builder, if

you really want this to work kind of

like in a production setting, you

definitely need to know how to code. And

there is a lot of configuration and

setup that is not that easy to do. And

just to give you a quick idea of what I

mean here, if I go to the chatkit Python

SDK, you can see it doesn't even have a

readme file here. It just has this like

random Apache license that we're having

a look at. Pretty much a brand new repo

with like kind of no activity and

nothing going on. And this is what

they're expecting you to look at to

learn how to use the SDK. So yeah, it's

uh you know, early days here for a lot

of the developer or more advanced tools.

Anyways, let's go back into the agent

builder. Let me show you this agent that

I built and kind of how you could

replicate the same. And you'll notice

here that OpenAI is really pushing

towards building kind of agentic tools

and allowing developers to build AI

agents. And that's because as we advance

more with AI, it's a lot less about just

LLMs and how well they can reason, but

more so about the actions that they can

actually take. Now, that's exactly where

today's sponsor as well comes in, and

that's Rube.app. Now, think of Rube as

your AI's chief of staff. Not just a

notetaker, but a command center. Once

you connect it, Rub sits inside of your

existing AI tools, whether you're using

chat GPT, claude, cursor, or even VS

Code, and it gives them the power to use

real apps securely and autonomously. Now

look here, I can connect this directly

inside of chat GPT. It also works inside

of the agent builder, and it's built by

Composeio and it acts as a universal

action layer across more than 600

applications. So things like Gmail,

Notion, Slack, Salesforce, even your

calendar. You just authenticate one time

and from then on your AI can execute

full workflows in plain English. So

instead of prompting something like

summarize my emails, you can go all the

way. Find all unread emails from the

past week, summarize the key points in

notion, and message my team on Slack if

any need follow-up. Rube automatically

handles the right tool connections,

authenticates securely, and executes

each step in the optimal order, all

within your chat. It also has memory. So

that means it learns how you work, who

to ping, how you name things, when you

prefer summaries, etc. Now, it's the

first real unified action layer that

I've seen that actually feels like a

natural extension of your AI. It's free

right now while it's in beta. So, if you

want to turn your LLM into something

that can actually do things, go try it

out at the link in the description.

Anyways, let's get back into it here and

have a look at these agents that you can

build with the agent builder. Okay, so

in terms of the agent builder, let me

give you a demo of one of the ones that

I've built so far so you can see kind of

what's possible and then we'll go into a

blank flow and I'll show you kind of the

basics of connecting and some of the

limitations that it does have. So what

I'll do is I'll just press on preview

right here. And from here I'm able to

test my workflow. So the flow that I set

up here is that I want to use multiple

agents to help me generate an outline

for a YouTube video. So my idea is that

first I want to generate kind of like a

viral YouTube video title. I want to

select which title that I want to

generate the outline for and then I want

to have the model go ahead and generate

a full outline and let me revise it

based on my feedback. So you can see

that that's kind of everything that's

happening here. So the first thing I'll

do is I'll just tell it you know I want

to generate a YouTube video for open AI

new AI agent builder. Okay. So I just

tell it that and then we can see we can

actually watch it run through this flow.

goes into the if statement, goes here to

the video title generator and then

starts generating our titles. Now, we

just got the output, but you'll notice

here that it actually used a tool that I

gave it. So, it was searching the web,

kind of looking for information on the

OpenAI agent builder, and then what it

did is it generated a bunch of titles in

this JSON format and displayed it using

one of the new chat widgets. Now, this

widget that you see here comes from

chatkit. Again, we'll talk about in a

second, but that's how I'm able to

display this in kind of a nice format.

Unfortunately, pressing on these doesn't

work directly inside of the preview. In

order to interact with the widgets, you

need to connect this to your own backend

server and set up honestly quite a bit

of code so that you can actually track

the state and kind of register the

events and what are being pressed with

these various widgets. But regardless,

what I can do now is pick one of these.

So maybe something like I built three

agents, right? And then I can approve

this. So it says, would you like to

select one of these titles or do you

want to try again? If I press try again,

then we can generate more titles. If

not, I'll press approve. And then it's

going to wait for me to actually select

the title that I want. So now I can just

paste in the title. You know, I built

three agents with agent kit. You'll see

now that in this if statement, it's

going to go to this next agent where it

tries to parse out the title from the

text that I provided. And then what it

starts to do is ask, okay, do you want

to generate, you know, an outline for

this video? So in this case, three

agents. I'm going to go ahead and press

on approve for that. And then what it's

going to do is start generating this

outline for me. Now, the way you set up

the flows here is not super intuitive.

And to be honest, I wish they had a lot

more blocks and options because for

example, you know, I can't just press on

one of these things and have it be

selected. So the only way I can kind of

like select an option from my agent if

I'm using this type of mode where I'm

not trying to write a bunch of custom

code is if I type it in, right? Which is

why I need to kind of do this repeated

step of typing in this title when really

I should be able to just like press it

and have the outline generated. So,

there's a few weird things like that you

that you'll notice with the uh kind of

flow as we start building one. But

you'll see that what it's done now is

generated this outline for me. So, 12 to

14 minutes blah blah blah kind of gives

me the outline of the video. And then if

I want, I can start chatting with it and

revising the outline. And if that's the

case, we would go into kind of this top

loop up here because of how I've set up

the if statements. Now, the interesting

thing about this agent builder is that

it does allow you to persist state. So

you'll notice that I have these kind of

set state blocks here where anytime I do

something or make a decision, I can

change the state which then will adjust

what's going to happen in the next run.

So for example, you know, we go and we

generate a title and then I set the

state saying, okay, we've already

generated a bunch of title ideas. Then

when we select a title, I set the state

to indicate what title we've selected.

And when I generate an outline, I save

that outline in the state. By having

that different state, I'm now able to

redirect the agent to go into different

paths and kind of use different AI

agents so that it can do something

different based on the current step that

we're on in this flow. Now, a lot of

other AI agent builders actually do this

a lot better in my opinion, but at least

for a first stab at, you know, OpenAI's

agent builder, this is pretty good and

the state is very useful because it's

persisted. Anyways, that's just a quick

example of something that I personally

built here in the agent builder when I

was kind of learning this and messing

around with it. Now, what I want to do

is get into a blank flow and kind of

show you how you can create your own. Go

through some of the blocks and talk

about how to connect them because it's

not extremely intuitive. So, if you go

into the Asian builder, you can just do

that by searching, you know, agent

builder OpenAI. And if you have an

account, you're able to sign in and

access it right here. You'll notice that

kind of in the main window, you actually

have a bunch of different options. So,

you now have stuff for, for example,

creating audio, right? Or getting text

to speech. You can do image generation

here. I haven't messed with that too

much. You can have different assistants

which work quite a bit different than

the agent flow there. You can view your

usage. These do use a lot of tokens so

just be careful. In my case, I think I

used like 10 bucks the other day messing

around with it. You can view your logs,

your storage batches, all of that kind

of stuff. And something interesting here

is that while the agent builder does

support vector search, so it allows you

to actually search through vector

databases and find information, in order

to do that, you need to use a built-in

vector search with OpenAI. So you would

have to create your own vector store or

upload your own files here to be able to

pull that data in directly natively in

the agent builder. Now you can do this

from code which I'll show you in a

second. Uh but it is obviously easier in

this kind of flow. So if you come to the

agent builder you'll see that there's a

bunch of different templates. You can

have a look at them. I don't find them

that useful to be honest with you. So

what I've been doing is just creating a

new empty agent and kind of going from

here. So, now that I've made a new

agent, I'll just build like a quick flow

and show you kind of how to connect it

and some of the options that are worth

going over. But also note that you can

use this directly from the agents SDK.

So, for example, you can actually just

copy all of the code right here. And

this is a kind of textbased

representation of the agent that you've

built. So, you see we have, you know, a

new agent, we have a workflow. In order

to run the workflow, we keep track of

the conversation history and then we run

the agent. And if I were to go here and

add like another kind of I don't know

connection and then we go up here to

code and we look at the agents SDK,

you'll see it automatically adds the

code for the guardrail. So if you want

to do something more advanced, you can

do that by going directly into the code

and modifying that or just running it

natively with the SDKs on your own

computer. Again, that's going to take a

lot longer, but you can do that. Now,

you also have the option here of

embedding this using Chatkit. This is a

little bit easier than running all of

the code here. What this allows you to

do is essentially rely on OpenAI servers

to kind of host your agent. And what you

can do is you can embed kind of the chat

window and all of the widgets directly

on your own front end. And then you can

essentially send the request to the

OpenAI backend, deal with the agent, and

then get all of the feedback on your

front end. Like I said before, does

require a little bit of setup there, but

this allows you to have a lot more

customization and to actually interact

with the widgets and create some more

complex flows. If you guys want a full

tutorial on this aimed at developers,

I'm happy to do that in the future. So,

just let me know. But I wanted to just

let you know that it does have these

features and you can get more advanced

as a developer if you want to. You're

not limited just to this kind of visual

flow builder. Anyways, let's start

building something quite simple. So, if

we start going through some of the

nodes, you'll notice that you always

need to start with a start node. Now,

from this start node, you're able to

have various state variables and you can

define them at the beginning or you can

leave them undefined. So, for example,

we could have something like the user's

name, right? And we can just leave that

as an undefined value to begin. We can

have an object. We can have a list. And

with this state, because it persists

between the different runs of the agent,

you can create some more complex flows

where you for example like ask the user

for their name. After you get their

name, you ask them, you know, what they

want to order, something along those

lines. So to show you an example of that

flow, we can have some agent right here.

We can call this like name collection.

From here, what we're able to do is give

it a system prompt. So that's what this

instruction is right here. And we can

say something like you

need to let's say ask a user for their

name find their name and return it. If

there is no name

then return null or something. Okay

great. So you can give it kind of the

system prompt explaining what it needs

to do. If you want to add context to

this prompt you can directly do that by

just passing in the context. Now what I

suggest doing is keeping this as the

instruction prompt and then pressing

this plus button here which gives you

the user prompt. So this one is the

instructions. Then from here you can add

an assistant or user prompt. So here

what we can do is just add the context

which is this. So this is the from the

start node whatever the user typed in

the workflow.input as text and now what

will happen is it will read through this

message use these instructions try to

pull out the name. Now from here you can

choose things like if you want to

include this in the chat history you can

of course pick your model. You can just

leave it on GPT5. You can put the amount

of reasoning that it should do,

especially if it needs to plan like a

larger task. In this case, it's minimal

because we just want to get the name.

And then if you want, you can directly

add tools here. So, in terms of adding

tools to the agent here, this really

only works well if you're going to run

this in your own environment and you're

going to have your own backend setup.

The way that the tool calls work is that

if you use a function for example, you

have to write in the definition for how

this function should be called and then

the agent will essentially generate a

tool call that you would need to

manually handle yourself on the back

end. So if I just generate something

like you know tool that gets weather or

something so you can just generate it

with AI it will create this kind of tool

spec for us here but it won't actually

perform the action for that tool. So if

you have a look at this spec here, we

define what the tool call should look

like and how this function should be

called. But if the model generates a

tool call, we don't know what the actual

function is, right, for getting the

weather. So we would have to actually

implement that ourselves on our server

to actually get the weather and then

return that back to the model. So while

it's interesting, it does require a lot

of kind of developer intervention. So if

you want to use some of those tools,

keep that in mind. This requires you to

actually go into the code, write the

tool yourself, and kind of intercept the

tool call from the model and then handle

that. Now, if you want to use, for

example, a client tool, same thing. You

can write a client tool, and in this

case, it will be triggered directly on

your front end, whereas the other tools

are going to be triggered on your back

end if you're hosting this agent. Now,

there's a bunch of other stuff here. I

won't go into all of the settings, but

this so far should collect the name. And

then what we can do is we can change the

output format. So, for the output

format, we have a few options. Text is

the default. We also have JSON and

widget. Now this is extremely useful

because a lot of times you want these

models to return something structured

that's consistent. So in our case we

just want it to return a name. So what

we can do is we can have output format

which is JSON and we can go here and

define the schema that we want it to

return. So we can go to add property

here and we can do something like name

and then we can give a description and

say the name the user entered like that.

Right? And then we can go to another

property and we can do something like a

boolean and say name found and we'll say

if a name was detected. So now what will

happen if we spell this correctly is the

model will return only this information

to us. So we'll give us an object that

contains this name field and this name

found field and we can then use that to

kind of figure out what to do next in

our flow. So I'm going to update this

here. We now have the response schema

and what we could do now is we could go

into something like an if statement,

right? So I can now put this into an if

statement and I can start writing some

conditions. So I can do something like

if and we'll have the case. So for the

case name we'll say name found and then

the condition is we can look at the

output that came from this agent. We can

look for example if the name was found.

So we can say if the name was found was

equal to true like that then we can do

something and then we can have another

case which is an else if or we can just

leave it as else. So here we're going to

say if the name was found then what we

can do is we can go into maybe another

agent and we can ask the user to do

something otherwise we could just end

right and we can bring in this end node.

So if we put in the end node we'll just

immediately terminate it right there.

Otherwise, we can go into this agent and

we'll just say something like answer the

user's

question and always let's see like this

always refer to them by name and then

we're going to put the name in here so

we can add the context which is their

name. Perfect. And then that's kind of

all that we need. And then what we could

do after this is we can go and we can

end. So that's a very simple flow. If

you want to test the flow, you can go to

the preview and you can say something

like, "Hey, how are you? My name is

Tim." Okay, so let's wait for this to

run and let's see what happens. So,

we're going into the name collection. It

says the name is Tim. The name was

found. And then we go into the if

statement. We go into this agent. And

then from the agent here, it says, "Hi,

Tim. I'm doing well. Thanks for asking.

How can I help you today?" So, it didn't

prompt us here to actually type

something in again. It just went

directly into this agent and kind of

executed that um instruction. And that's

the thing that I don't really like about

this is that I can't kind of enter

another text string later on. I need to

restart the flow in order to do that. So

because of this limitation where you

can't really provide new input in the

middle of the flow, it means that you

need to build these agents in a certain

way so that they can kind of run again

from the beginning but go down a

separate path based on the current

state. Now, this is really only a

limitation when you're doing it inside

of the agent builder like I am right

here. If you use custom code, then you

can inject current state by using things

like widgets, which again I keep saying,

but I will show you in a minute. But for

now, let me show you the pattern that

I've been using so that this agent

actually makes sense because the idea is

we want to ask the user, okay, like

what's your name? And then we want to

use their name throughout the rest of

the flow in future conversation. So what

we have right now doesn't really make

sense because we ask the user their

name, but then if they don't have any

question in that text, when we go to

this next agent, it doesn't really do

anything for us. So we need to move

things around a little bit where rather

than us kind of doing this if else right

now, we actually do it at the beginning.

So let me just kind of disconnect these

agents here and we're going to put the

if like this and we're going to pretty

much just change everything. So

essentially what we're going to do here

is we're going to start by adding some

state. So if we go to start, we have the

name, right? Okay, so that's good. So

the state's already there. And now what

we're going to do is we're going to say

okay if the and this is going to be

name. So we're going to say if the

state.name does not equal null which

means it's not empty essentially. So we

have some name that means we found the

name. So if we found the name we're

going to connect it to this agent like

this. Otherwise, what we're going to do

is we're going to go to this name

collection agent. And then after the

agent collects the name, we're going to

use this set state block where in the

set state, we're going to say that we

want to assign to the variable name. And

what we want to assign is the name like

this. Okay. So, we're going to say all

right, we go to the name collection

agent. We get the name. If there is some

name, right, we assign that as the

string. Okay. And then we can go to end.

Now, there's other ways that we can do

this that makes it actually work a

little bit better. So, in fact, let's

change this a bit just so I can show you

how this works. So, rather than just

storing the name, we're also going to

have a boolean and we'll say name

found like that. And by default, we can

make this equal to false. So, now in our

if we can actually make this a little

bit more clear and rather than

state.name, we can say name_found

like that. So, we can say if the

name.found is true, then what we're

going to do is go to this agent right

here where we'll create the user.

Otherwise, what we can do is go here and

then we can set state and we can set

multiple things. So, we can set the name

as well as we can set if the name is

found and we can assign this the value

of true. Okay, so we just have two sets

here inside of this set state and then

we end. And then here, let's make sure

the name is correct. It is. So, now we

have the if else at the beginning. So,

if we go and we preview and say, hey, my

name is Tim. Okay. And just wait one

second. And now you saw we went into the

name collection where it says okay you

know the name is Tim the name found is

true. Now if I type like hey how are

you? We should see that we go into this

top agent here which we do because the

name state was found and was already

set. So that's kind of how we do this

with the state. So now we get the

response from the agent where it asks us

how it can help us. So that's kind of

the pattern that you're typically going

to use is you're going to set the state

and then here you'll check for the state

at the beginning and then you can go

down a different path if that's the flow

that you want to follow. Now where this

gets even more interesting is when you

can start integrating widgets. So for

example you saw that when we collect the

um kind of name it doesn't really give

us any output right what it does is it

gives us this JSON but it's showing that

JSON in the chat which doesn't really

look very nice. So what we can do is we

can actually just uncheck this so we're

no longer displaying the response in the

chat. And then what we can do is we can

kind of add another agent in here where

we can maybe greet the user before we

move them to the next stage. So we can

just connect another agent for this

agent. We can just call this greeter or

something. Going to say greet the user

with the name. Okay. And then we're

going to add the context which is name

and a random fact. Okay. So now we can

actually just output some text and we

can see that. However, if we want, we

can make this even more interesting by

integrating what's called a widget. So,

rather than going output format to JSON

or text, we can use widget, which comes

from checkin. Now, if we select widget

here, what we're able to do is add a

widget. And in order to add a widget, we

need to create one. So, I'm going to go

to this create button right here. And it

brings me to this new page, which is

called the widget builder. Now, from the

widget builder, we can look at existing

widgets. You can see these are examples

of like chat widgets which is a way to

return data in kind of a nice format. So

you can see that we have like this

weather format, right? We have this date

format or calendar format. So what we're

able to do is create these custom

widgets, tell the model, hey, we want to

output the text in this widget format

and the model automatically returns data

that can populate these widgets. So for

example, here's a widget that I actually

made. It's like this kind of YouTube

outline widget. I'm not using it right

now, but it's one that I set up. We have

this suggested videos widget. You

already saw this in the first example.

So you can make these widgets whatever

you want. Now there's also existing

components that you can use to kind of

build these widgets out. You can style

them. You can have charts. But what's

really interesting is that you can just

use AI to make the widget. So for

example, I can just ask something like I

want a widget that displays what the

user's name is and a random fact. It

should be colorful and fun. Okay. So I'm

going to go here and press enter. and

then it will just generate a widget for

us which we can download upload back

into the agent builder and then we can

output text in that widget format. Okay,

so it's been a minute. You can see here

that it's now generated a widget. We

have like a dark theme one as well as a

light theme one. And what we're able to

do is see the schema for the widget

which is the information that our model

would need to pass in in order to

generate this widget. Uh this is the

default information. Sorry, this is the

schema. My bad. And you can see what it

looks like, right? So this is the code

and then this is the widget itself. Now,

what you're able to do here is simply

download the widget. So, you can just

press download. I'm going to save it

into my widgets here. And then what we

can do is go back to the agent builder

and we can simply upload it. So, go to

widgets. I'll select the widget that I

created. It shows us what it looks like.

We can view the code for it. And now

what we'll do is close. And now, if we

run our flow, we should be able to see

this widget. So, I'm going to say, hey,

my name is Tim. Notice, by the way, you

can also see the state variables here on

the first run. And you can modify those.

And I'm going to press enter. So you can

see it now greets us. It says hi Tim. It

says here's a fun fact. And then it

gives us a random fun fact. And if we

say what is the weather or something the

weather today. Okay. And we just go

ahead and press enter. It should now go

into the other agent because it already

has our name. And then it should give us

the answer. So let's give this a second.

It's reasoning blah blah blah. Looking

up the weather and says I can help you

with that. You know tell me the zip code

whatever. Okay. Anyways, there you go.

That is a simple example of building the

agent. Now, of course, there is a lot of

other tools that I didn't yet go into,

right? For example, we have user

approval. With the user approval, it's

pretty straightforward. It just allows

the user to either do approve or reject.

You cannot change the name of these

buttons. That's it. So, you can just

have one flow that you go off of if you

want to approve something, one that you

go off of if you want to reject

something. And this is kind of the one

way that the user can intervene in kind

of the middle of the uh flow. But that's

pretty much it. Let me just delete this

one. You also have the wall loop. Um,

this allows you to keep looping based on

some condition as you can see here.

However, this is pretty tricky to use.

So, I wouldn't suggest it unless you

really need that flow. You have notes,

right? So, you can just put a note and

says, you know, check this, whatever,

right? If you want to notify kind of

what's going on in there. And then you

have the file search. This only works

inside of a vector ID created with

OpenAI. So, you can create your own

vector store, upload data in there, and

then search for results. But again, you

need to do that directly in OpenAI,

which is makes it just not that useful.

You have guard rails. What guardrails

allows you to do is kind of sanitize

text before it goes through your flow.

So, we can make sure there's no

identifiable information. We can check

for moderation, jailbreaks,

hallucinations, etc. We can go in here

and kind of add all of this different

information and change all of the

settings here so that we can kind of

make sure that our agent is safe and

it's not allowing users to try to hack

it or, you know, ask for things that

they shouldn't be asking for. And to do

that, you would just connect that

directly to the start node. So, let's

just delete this, right? And then the

guardrail can go into the next flow. And

from here, you can actually just have it

kind of quit immediately, right? So, for

example, if we do this and then we fail,

we can just go directly to an end block

where now we won't go through the rest

of the flow because the guard rails

failed. So, that's pretty cool feature.

That's interesting that they added that.

And then you have MCP. Now, for MCP, you

can natively connect to some of these

tools like Gmail, Google Calendar,

Google Drive, etc. However, when you do

this, it's not very easy to connect. So

if you press this button that says get

access token, it brings you to this

crazy page where you essentially need to

do this kind of manual setup where you

you know authorize the API to access a

certain set of features and then you

need to exchange this token for this

access token and then provide this in

here which expires in a few days and

overall it is not very friendly which is

why I did not show it in this video. Now

same thing for some of the other

connections uh you know PayPal etc. you

need these all these access tokens which

are not easy to access and then you have

the server where you can you know put in

a server like the notion MCP server for

example however the only way that this

authentication works is using either

custom headers or an access token and

API key and it doesn't support an OOTH

flow which is how most of these MCP

servers authenticate. So, I'm not going

to dive into this too much, but

essentially, yes, you can add MCP

servers here, but it only works if

they're an HTTP MCP server and if they

do authentication using some kind of API

key or custom header, not if they use an

OOTH flow, which now is kind of

standard. Um, which is very unfortunate

because if they did implement the OOTH

flow, which means like you can kind of

sign in, it will grab the token for you,

then it would make this a lot more

useful. But all of the MCP servers that

I wanted to use, I just cannot use from

this agent builder tool because of how

they want the connection to be handled.

Uh which is quite unfortunate. Now

that's pretty much it. There are a few

other interesting tools. For example,

like you can evaluate your agent and you

can test it with multiple different uh

what do you call it? Um kind of flows

here. You can see how long it takes to

run inside of these different steps. You

can actually have a greater you it's

funny you can use like a GPT model to

grade your own GPT models and you can

see how well that's performing. And if

you get outside of these workflows here,

you can go in and you can actually look

at, for example, fine-tuning where you

can fine-tune models and you can have

this evaluation where you can evaluate

different kind of data sets in your

agent. So you can actually name a new

data set, right? And then you can

connect this to an agent and you can run

through and test how it performs on

those different data sets. Pretty cool.

They added a lot of interesting stuff

here, but to be honest, it only becomes

useful if you're going to actually

integrate this with your code. So while

yeah, we can build these cool agents. We

can mess around with them in the preview

window. If you want in any

interactability, if you want to be able

to pause the flow, if you want to change

the state dynamically, you are going to

need to write some code to do that.

Because for example, if we go back to

the widget builder, right, and we just

go to the gallery, you'll see that all

of these widgets have like buttons like

add to calendar, discard, we have forms,

right? You know, where we can enter all

of this data. But this only works and we

can only use these um kind of inputs if

we connect this to our own backend which

is not made that clear by OpenAI and is

really limiting when you're using the

agent builder in this kind of you know

UI mode as opposed to if I can go back

to it the the code mode. So I guess I

got out of it but that's fine. Anyways I

think with that said guys I'm going to

wrap up the video for now. I wanted to

give a quick tutorial show you some of

the limitations as well as the

capabilities of this tool. Overall I

think it's really cool. I think OpenAI

has the possibility to make this the

best agent builder out there. Right now,

I would say that it's pretty limiting,

especially from a drag and drop

perspective. If you want full control

here, you do need to write some code and

integrate it. And I am planning on doing

that in the future story and making a

full tutorial on how to do that. So, if

you're interested in that type of video,

leave a comment down below and let me

know. And I'm sure I'll be covering this

more on the channel in the future.

Anyways, if you guys enjoyed, make sure

to leave a like, subscribe, and I will

see you in the next one.

[Music]