Loading video player...
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]
Get started with Rube today: https://rube.app/?utm_source=Social&utm_medium=Youtube&utm_campaign=2025-09&utm_content=Tech%20with%20Tim Today I'm having a look at OpenAI's new agent builder. 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 a quick demo and tutorial, and then share with you my thoughts. DevLaunch is my mentorship program where I personally help developers go beyond tutorials, build real-world projects, and actually land jobs. No fluff. Just real accountability, proven strategies, and hands-on guidance. Learn more here - https://training.devlaunch.us/tim?video=g93XqSRxcAs 🎞 Video Resources 🎞 OpenAI Agent Builder: https://platform.openai.com/docs/guides/agent-builder ⏳ Timestamps ⏳ 00:00 | Agent Builder Intro 01:00 | AgentKit Announcement & Info 05:21 | Advanced Agent Demo 09:29 | Tutorial & Agent Build Hashtags #OpenAI #AgentBuilder #SoftwareEngineer