This content introduces agentic workflows as the future of business automation, emphasizing their ability to create self-improving, reliable, and highly efficient automated systems that can significantly boost productivity and revenue.
Mind Map
Click to expand
Click to explore the full interactive mind map • Zoom, pan, and navigate
Welcome to the most comprehensive course
on agentic workflows ever created
absolutely [music] free. Up until
recently, the term agent was associated
primarily with a ton of hype and very
little in the way of actual business
value. But today, the tech is now good
enough that Agentic workflows are
definitively here and they are without
[music] a doubt the future of workflow
building. Now, I'm not exaggerating when
I say these will quickly run the entire
economy. So, if you've been looking for
a way to start learning about agentic
workflows to automate business processes
and potentially generate a lot of
revenue either for yourself or maybe the
companies that you work with, you guys
are in the right place. My name is Nick.
I've scaled two agencies to over
$160,000 in combined revenue. I also
lead the most profitable AI automation
community out there. It's called Maker
School and it generates nearly $300,000
a month in profit. I say this to make it
clear. I'm no stranger to revenue or
profit. And this course has been created
with all that in mind. My goal here was
not just to teach you guys technology
for techny's sake, but to show you how
to use these things in an actionable way
that helps you make real money. So, it's
a lot less on the hypothetical and a lot
more on the immediately applicable. This
course will guide you through three
things. First, I'm going to show you
guys some practical examples of agentic
workflows so you can see what's possible
like right now. I'm going to frontload
this because I think a lot of people
have no idea how powerful these things
are yet and I want you to see them for
yourself. Second, I will show you how to
build an agent environment that does
something called separation of concerns
using a simple framework called DOE or
DO for short. That stands for directive
orchestration and execution. Third, I'm
going to show you guys how to create
what are called self-anneeing agentic
workflows which are workflows that
maintain and improve themselves over
time. We will set up an agentic workflow
environment in a popular IDE called
anti-gravity. You don't need to know any
programming or have really any workflow
building background. Uh I'm going to
guide you guys through everything from
start to finish. And by the end, you
will have an agentic business operating
system that lets you do most of your
economically valuable work, probably
dozens of times faster than usual
through a simple text box. I've also
added timestamps for everything in the
description. So feel free to watch this
over multiple sessions if you want.
That's how I designed it. And if you'd
like, please consider bookmarking this
video right now so you guys can easily
come back to it later. Ready? Let's get
started. Okay, so next I'm going to show
you a few live production grade examples
of real agentic workflows that are
running in my business right now. These
are not hello world, you know, beginner
examples. These are flows that are
actually generating me revenue and
saving quite frankly dozens of hours of
manual labor every week. They also
operate with a level of reliability that
most people think is impossible with
current AI. So, first some background
into my businesses so we're all on the
same page. Uh my main company is called
Leftclick. It is basically a souped-up
sales and marketing agency. We use AI to
generate leads for a variety of
businesses, primarily through outbound
marketing, which means cold email. I
also run a dental marketing business
that does around $2 million a year. And
this is similar, although they generate
opportunities the other way via inbound
marketing, which is mostly ads and PPC.
So, first I'm going to show you a simple
system that I put together in less than
15 minutes start to finish that
automates a very common task that we
used to do pretty much every day. Uh, to
make a long story short, we are going to
start by scraping a bunch of leads and
then getting a bunch of email addresses
and then doing some enrichment and then
some AI personalization on top. And I'm
going to start all of this with
literally just a single message. It's
going to take me a few seconds. The ID
we're going to be using here, as
mentioned, is anti-gravity, which is
Google's recent agentic platform. And I
don't want you guys to focus as much on
the code or the way the workspace is set
up. Just the example cuz you guys will
be able to build something like this at
the end of the course. Out here in my
garage, I'm just kidding. Out here in my
anti-gravity IDE, I have three panels.
On the lefth hand side here, I have an
explorer. This is just a file explorer
similar to any that you guys have
probably used on a Mac or a PC. I just
want you guys to ignore literally
everything here except for the
directives and the execution folders.
Directives are where we store highle
instructions surrounding how to do a
task. Execution is where we have the
tool layer where it'll actually go and
call specific scripts that it itself has
generated in order to do a task. Now,
it's not very important that you know
exactly how all this stuff works right
now. I'm just doing a demonstration, but
essentially inside of scrape leads, we
just have highle instructions that guide
it through a process. Then inside of
scrape leads. we have a script that
actually does the scraping. Um,
obviously the model could try and do all
of this stuff itself with the base tools
that it has access to, but that's where
you run into issues where the model is
so flexible that it doesn't actually
accomplish the stated business need
reliably enough. What we do instead is
we create temporary scripts. If those
scripts are good, then the model keeps
them and then it adds complexity over
time. Okay, cool. Next up, we have uh
this middle panel here which just stores
some highle access to various things.
Agent manager, edit coding, line code
with agent, etc. In the right hand side,
we actually communicate with the agent.
So, said I wanted to scrape some leads.
I'm just going to scrape um 200 realtors
in the United States. And look at that.
I even didn't spell United States
correctly, but that's okay. I trust that
the model with this framework will be
able to do what I asked it to do. So, it
looks like the very first thing it's
doing is analyzing directives and
execution. It's then going through
scraping all the information. Now, it's
going to open up these thought
processes, and you don't necessarily
need to look at them. That's not
necessarily relevant. Um this thought
process here is just what the what the
agent is going through. Uh and it's
feeding its outputs back to its inputs
over and over and over. This is the task
um implementation plan that is
generated. It's basically going to start
by reading this stuff, then create a
plan. There we go. Then it's going to um
do some execution steps and then give
some verification. Then at the end,
we're going to have a Google sheet with
a bunch of leads, which is pretty great.
Now, at this point, you can do a couple
of things. I mean, what I do is I just
open this in the right hand side of my
Mac and then I'll just like have
something on the left hand side of my
Mac and it'll just do that work and then
when the agent is done doing the task,
which may take 5 or 10 minutes. I mean,
we're getting to really long time scales
here, it will present me the results and
then I can do whatever the heck I want
with it. Alternatively, we can look at
what the agent is doing a little bit
more under the hood. So very first thing
that it's going to be doing is if I go
to a scraping platform here. Now I know
for a fact it's running this on a
service called ampify because that was
some of the logic that I built into the
highle directive. And so I can actually
go and I can verify that we have indeed
scraped what looks like 25 initial
prospects. We scrape 25 initial
prospects cuz that's part of the
directive. The directive says hey I want
you to assemble a big list of what you
think are realtors using a bunch of
filters. If you find uh that more than
85% of these are in our target market,
then I want you to uh keep them and then
run a full scrape. If they're not uh 85%
or more within our target market, then I
want you to redo your filters, sort of
self anneal until you find the right set
of filters that actually accomplishes
that stated task. And so that's what we
did over here. We ran a test scrape,
found 25 leads. It then went through and
verified how many of those leads were
actually in our target market. It
accomplished this and realized more
than, you know, 85% were. And now it's
gone through and it's actually found
those 200 leads. So, as you see, we
received a console notification saying
the leads are now ready in the data set.
Now, what it's doing is it's going to
present them to me. Okay, it's now
delivering me that information. You can
see it right over here. So, we actually
have the Google sheet that contains all
of those leads. And as part of my
request, it's even going through and
enriching lead email addresses using
another service. Now, this may seem
pretty complex, but I want you guys to
know all that I needed to do in order to
get a workflow that did all of this
totally autonomously was I gave it a
brief bulletoint description, and then I
spent maybe 5 or 10 minutes going back
and forth with it, having it construct a
script that does this. Now, as a result,
we ended up getting 178 out of the 200
emails. And I'm just rechecking this.
We've taken those 178 now to 193 because
we've done, as I mentioned, some
enrichment using another platform. On
the right hand side here, it just
crafted a new column called casual
company name. This is just part of my
cold email copyrightiting SOP within the
company. When we send an email out to
people, we don't use their company name
because that would be kind of silly. You
know, the Bal Serac group of AB and
co-realtors, for instance, is very long.
Could you imagine saying, "Hey, Pete,
love the Berzac group of AB and
co-realtors." No. Realistically, if
we're sending a cold email, we wanted to
say something like Baliserac group. And
as you guys could see over here, we've
actually done that. It's gone through
and it's crafted a casual version of
that company name Berzac just using
logic that I had previously baked in.
Now coming back to it, we can see that
we now have the results and it's
actually formatted it in a very brief
overview message that I've asked it to
do. It said it scraped 200 realtors for
the United States, enriched 15
additional email addresses. We casualize
191 company names. Then we even have
access to the Google sheet. So I'm
opening up that Google sheet again. It's
the same thing that we had earlier, but
just for posterity sake. And uh all of
our information is right here. How long
did that whole process take me? Very,
very little time. I now have the data in
a format that I can do basically
whatever the heck I want with. Okay,
let's take a look at another example.
This time we're going to be automating
the process of a post sales call
proposal and email. You can absolutely
build this stuff procedurally like
through old school drag and drop,
make.com, nan, etc. But it's a lot less
flexible and the system typically needs
to be maintained and updated pretty
regularly with agentic workflows.
Instead, you just build it once and it
will continue to improve itself reliably
over time, which is wild. Okay, so let
me show you guys a second example. Now,
hypothetically, let's say I wanted it to
generate a proposal for me. This should
illustrate just to what degree you can
use these sorts of things as basically
assistance in your business. But
basically, I have a directive store
that's pretty high level that's just
called create proposal. It then guides
you through a bunch of lower level
scripts like create proposal, create
content calendar, and stuff like that.
So, I'm just going to say create a
proposal. I'm not even going to give it
any context. I've stored all of this
stuff inside of the directives. In this
way, we realistically are building like
a co-orker, like an AI employee in our
business. Imagine if you just sent
somebody a Slack message like, "Hey,
create a proposal." Well, now we're
going to get the results. I'm using a
different model here just to demonstrate
that you can use whatever models you
guys want. In this case, it's now Claude
Sonnet 4.5. Although Gemini 3, as of the
time of this uh video, is a really good
model. You don't necessarily need to use
like the best most cutting edge models
for this information. And you can see
it's still interpreted and understood
all of my requests. It's even going as
far as ask me a bunch of information.
So, as you see, we have structured info,
call transcript, or quick details. So, I
could actually provide like a call
transcript, or I could have it check my
Fireflies or whatever the heck. In this
case, I'm going to give you guys a very
brief uh company profile. This is a real
customer, but I'm going to be obscuring
all their names and stuff like that, so
we can generate a proposal that actually
makes sense. All right. And I've just
copied and pasted over a bunch of highle
information here. I'm just going to put
it in and press enter. Although, you
know, hopefully you guys see there
variety of different ways you could
input this info. You could just do it
through a call. You could just do some
highle basic details, whatever. It's now
um taking all that information and it's
actually going through and it's
generating a proposal based off of my uh
instructions. As you see here, we have a
pandock proposal task list now. So, it's
going to start by expanding the problems
and benefits. The reason why I built
this out is because I often just store
very high level understanding what the
client wants in my head. So, I will
literally just be on sales call and I'll
just say, oh, you know, person wants uh
45,000 in cost savings for whatever
platform. So, what it does is it takes
that information and it expands it based
off the context of the company. It'll do
a little bit of research into the
business and understand what it needs in
order to put something together that
actually looks nice. It'll do so
according to my tone of voice and and
everything like that. Okay, it's now
creating that panadoc proposal. Pumped
together just a giant API request for me
and it did so completely autonomously. I
should note like I didn't have to
actually do any of that information in
the highle instructions. I actually just
gave it some very brief instructions
like hey I want you to create proposals
in pandock for me and send follow-up
emails. Um could you create me a
directive for it? It's now sending a
follow-up email. It's doing this using
an MCP or model context protocol tool
that I've installed. And now it's
sending me a message saying, "Hey, we
created a proposal successfully." We've
also sent a follow-up email with a
four-part implementation breakdown. So,
I'm just going to commandclick this,
open up this puppy, and as you guys can
see, we have the proposal. Now, um I
should note that it didn't produce
everything in this proposal. I had a
template set up here. So, it filled in
all of the things in yellow. And this is
just a proposal template that I've been
using for a variety of purposes. And as
you can see, it's gone through and taken
my very high level details and then gone
through and wrote a cool proposal. So
systems are innately high leverage, but
this leverage can either work for you or
against you in your case. And there are
a few small persistent problems that are
currently impacting growth. Right now,
you're burning roughly 50k per year on
outreach in Apollo. Legacy tools are
built for a different era of sales. The
platforms are expensive, clunky, don't
talk to each other. And every dollar you
spend here is a dollar that could be
reinvested in growth. But instead, it's
locked up in bloated enterprise
contracts that don't deliver
proportional value, right? I mean,
obviously the prompt is, hey, write this
value base. talk about savings and so on
and so forth. We do the same thing for
solutions. Um we obviously have, you
know, a bunch of templated information
over here. We scroll all the way down to
the bottom. You can see we also have the
little investment section here that
includes a bunch of information around
um how much money they're paying in
month one, month two, month three and
beyond. So I mean I used a hypothetical
company name here and then an email
address. But yeah, this stuff works in
real production context. I use this all
the time. This was another system that I
developed in something like 15 minutes
or so. Very high level instructions. You
just give it a brief. You let it know
about the self annealing concept which
I'll cover later on in this course and
then voila, it goes and it does things
that are actually pretty economically
valuable for you. We're going to cover
how to make stuff like this throughout
the rest of the course. You guys are
going to know how to build simple
workflows like this in 15 minutes and
essentially just have an AI companion/
AI employee that goes out, does things
for you, and then returns carrying the
deliverable uh hoisting it above their
head and presenting it to you like a
king. It's pretty sick. Okay, so
hopefully it's clear. These agents are
not just chat bots. They are basically
universal interfaces let you control
software. Now the catch is there's
actually a fair bit going on behind the
scenes that you didn't see. If you were
to just open up chatbt or cloud code and
paste in a prompt asking it to do what I
showed you, it will almost certainly
fail. Maybe not the first time, but
it'll eventually hallucinate. It'll get
stuck in a loop. Uh might work once at
the beginning and then fail the second
or third times. Or maybe it'll tell you
that, you know, can't access a file or
whatever other edge failure case that
comes up. So if you're a hobbyist,
that's usually fine. And you know, a 50%
success rate is probably acceptable to
you. But if you're a business and you
make, I don't know, a million dollars a
month, that is unacceptable. You cannot
run a million dollar a month operation
on a system that only works most of the
time. If it even screws up literally 2%,
that is not just 2% of your revenue.
That problem could cost you a 100% of
your revenue. Consider what happens if
you try automating a workflow using
agents like this, but it's like to send
an invoice or something and you send the
wrong invoice to the wrong person. You
could literally lose a giant client
contract. So, we don't need just the
ability to do things. We need
reliability and consistency. Basically,
in businesses, we need a system that
works every time exactly how we expect
them to. So, to make this work, we need
to build a structure around the model
that forces it to be reliable, which is
what I'm going to talk about with you
next. So, the problem is really called
stochasticity, which is like
non-deterministic outputs. If you guys
were to ask an LLM to scrape leads from
LinkedIn, you know, it might work the
first time, but on the second or the
third time, it may also fail. On the
fourth, it may hallucinate a completely
different task. And on the fifth, it may
say, "Sorry, this is against
regulations," or something like that. To
make a long story short, this is not
something that is reliable enough for
that predefined business pipeline that I
just showed you. The reason why is
because in business, even a 1% rate of
inaccuracy can lead to a revenue
reduction of 50% or more. You know, this
is not academic theory here. It's not
just a business textbook. This is real
life. If you guys send the wrong
invoice, even 1% of the time, you don't
hurt your business by 1%. You could
completely destroy your whole client
base. And because LLMs are
probabilistic, aka they guess the next
token, and business logic is
deterministic, which means you need the
exact same output format basically every
time, the two are at odds. When you try
and make an LLM do everything, which is
planning, tool use, execution,
formatting, whatever, um the error rate
compounds. A good way to think about
this is if each step has a 90% success
rate, a five-step task mathematically is
0.9 raised to the 5 equals 0.59.
to deconstruct all that for you. That
just means that this task where each
individual step may be quite likely to
succeed on net only has a 59% success
rate, which is completely unacceptable
for any real business operation. Okay,
so to fix this, we don't just try and
make the LLM smarter. What we do is we
actually fundamentally change the
architecture around the LLM and we take
advantage of the LLM's built-in coding
tools to do a bunch of the heavy lifting
for us. So instead of asking an LLM to
do something directly, we're just going
to ask it to create a standardized piece
of code to do that thing, which is, you
know, philosophically the same thing
that people were doing 30 to 40 years
ago. There's no difference. Then it just
uses the code that it wrote to do the
task itself. This significantly
mitigates the flexibility of the outputs
and it also allows you to leverage what
AI is fantastic at, which is code,
because that's what everybody's making
AI to do, while minimizing what it is
bad at, which is reliable, predictable
flows. Okay, so how do we do this? Well,
in order to make this happen, we need to
split the work of the LLM into three
distinct layers. The first is the
directive layer. The second is the
orchestration layer and the third is the
execution layer. What's great about this
is this is the exact same structure used
by a lot of very successful human
organizations. You will have a manager
which is equivalent to the directive,
the employee which is equivalent to the
orchestrator and then the tools which
are equivalent to the execution. So, let
me explain the structure in real context
and then why the specific one is the key
to in my opinion unlocking reliable
agents. So, what do these three layers
actually look like? Well, here's how I
typically visualize them. We start with
the top, which is your directive layer.
Now, these include workflows, SOPs. For
people that don't know what an SOP is,
that just stands for standard operating procedure,
procedure,
and essentially what we do is we write
all these out in some form of easily
formattable text, which in our case is
going to be markdown.
And the specifics of markdown aren't
super important if you're not really
sure what that means. Essentially, it's
just a way that you can like format and
and add some form of structure to tax
without having to consume a ton of
tokens. And what these are, these are
highle instructions that just guide an
eventual orchestrator through what a
process looks like. So, I mean, an
example might be a recipe, right? You
are looking up a recipe on how to make,
I don't know, some tofu or something
like that. And step one says add soy
sauce, vinegar, and whatever to a
container. These are high-level
instructions, but all they do is they
describe what the agent is going to do
and define guard rails that an agent
eventually goes down and chooses of its
own accord. Okay, so highle instructions
are where directives come into play.
Now, from there, we obviously need
something to actually go and take those
highle instructions and then reason over
them. And that's where your AI agent
comes into play. Now, you notice that I
also wrote slash employee over here.
Why? The reason why is because this is
actually a very similar structure to the
way that most large organizations work.
Most large organizations will have
highle directives written as workflows
or SOPs in natural language. And then an
employee will be responsible for
digesting them, then converting them
into more actionable tasks. But anyway,
um, in our case, you know, for our
purposes, that's where our little AI
agent comes into play. So, our AI agent
essentially gets to do a reasoning loop.
And so, it is going to
read, if we just go here to the right,
it's going to read through our
directive. It's then going to choose an action.
action.
It's then going to execute said action,
and then it's going to evaluate the
results. This same loop here has been
called a million different things. I'm
going to leave it at read through,
choose, execute, and evaluate. But as
long as you understand that there is a
sequential series of steps that any sort
of software agent is going to follow,
you guys know more than enough. Don't
worry too much about various conventions
or acronyms or whatever. Those aren't
things that actually help you understand
and make money. Okay. So, these AI
agents go through these reasoning loops.
They coordinate and they're responsible
for the ultimate task management. They
function very similarly to maybe like a
mid-level manager or something like
that. Once you have chosen sort of what
to do next, you need to execute and
that's where the execution layer comes
in. And so essentially the AI agents/
employees in your business will then go
out and pick particular tools, usually
tools that it's already developed or
it'll go and it'll write tools in the
form of Python scripts. At least that's
my recommendation. a variety of
different languages you can use for
this, but Python scripts tend to be the
best just because Python are is the
language that most of these large
language models um were trained on
initially. There's an overabundance of
Python um you know code out there and
Python's used as like artificial and
synthetic data for a lot of these as
well. So they just tend to work really
well with Python. And then you know
these produce some sort of output. Okay,
this is the output. I don't know, could
be maybe some numbers, could be, I don't
know, some strings, whatever the heck
that the purpose of this Python script
is. In the example that I showed you
guys, could be a lead, could be a PDF.
And then that information actually loops
back here to the orchestrator, the
Agent, which then reads the results and
then can actually choose if it wants to
to go upstream and manipulate the very
directive as well. So this orchestrator,
you can kind of think of this as a glue.
Now, anybody here that's worked with
traditional noode or low code platforms before,
before,
this orchestrator works very similarly
to make or nadn or zapier or any one of
these platforms. Okay. Um, all of these
drag and drop platforms basically back
in the day and now are nothing more than
glue which routes business logic through
nodes and then allows you to choose sort
of what direction those things go based
off of some preset logic. And so the
orchestrator in this case is the make n
zapier lindy gum loop flow. It's just
now what we're doing is replacing that
orchestration with AI agents. So, a
agents are actually basically the
routers and they're responsible for
choosing what to do and when to do it.
What's really important here is there is
no code or any sort of executable
written in the directive layer. The
directive layer is literally just a
bunch of natural language prompts. When
I say SOPs, I literally mean SOPs.
They're the exact same type of standard
operating procedure that you would find
in any company, which is why this is so
valuable. If you take the DO approach,
you could literally take a pre-existing
list of all of the standard operating
procedures in a business and just drag
and drop them into your IDE and boom,
you've already accomplished one of the
three main layers here. Literally just
having a list of things to do. You can
then feed that into an agent, have the
agent refine, and then convert that into
lists of actionable tools so long as you
provided things like API keys,
connectors, and so on and so forth,
which is much easier than it sounds. So,
I don't know if you guys have ever
played a popular video game Minecraft
before, but if you haven't, essentially
what happens is you're this character
and then, you know, there's a bunch of
blocks around and you start off the game
by just like beating a block and then,
you know, the block outputs some some
wood or something like that. And as you
progress in the game, you can add a
bunch of wood to your inventory and
eventually put the wood together in
specific forms and then, you know,
instead of just having to to punch a
block with your hand like a savage, you
know, you could kind of build yourself
out some sort of hatchet. Okay. And it
starts off as a wood hatchet, but then
you can continue pumping down more and
more of these wood blocks and
eventually, you know, reinforce the
hatchet and start uh attacking some
stone or something. I'm obviously
butchering this. Anybody here that's
actually played this game to any degree
should know. Um, man, it's been a while
since I've fighted the the the Ender
Dragon or whatever the heck it's called.
But, um, to make a long story short, I
want you to think about tools kind of
like a character in Minecraft. You start
off with absolutely nothing in your
execution folder. Okay? All you do is
you give highle instructions and then
the agent will actually start making
things like, you know, a pickaxe.
Then it'll start making things like, I
don't know, like a hatchet. It will
start making things like, I don't know,
some sort of sword or armor. And what's
really cool, okay, is once it's made
these, it can then go back and reinforce
these and then it can upgrade them. And
eventually you can get to your little
diamond fortification or whatever um
where your stuff is just really really
good. It can, you know, replace one-off
endpoints with bulk endpoints or batch
endpoints. It can economize the code so
that it runs a million times faster than
it did initially. can go from like a big
O of N squared all the way up to like a
like an O of N or something like the
potential here is pretty unreal and once
you build this environment or ecosystem
just gets better and better and better.
Another way to think about this is I
don't know some sort of caveman let's
say in prehistoric times. This is Mr.
Sad Caveman because he doesn't have
anything and there's some big
saber-tooth tiger and I cannot for the
life of me draw a saber-tooth tiger. I
don't even think I'm going to try. My
god, that's about as bad as I thought.
It's looking more like Minecraft than
anything else. Um, you know, saber-tooth
tiger attacks him the first time. What's
he going to do? He's going to try
punching him. He's going to find a rock
on the floor. He's going to throw it.
Not all of these things are going to be
hyper effective, right? So, what he does
is, I don't know, go goes and makes a
spear. Next time you see a saber-tooth
tiger, what are you going to do? You're
going to pick up the spear. You're going
to use that, right? As you eventually do
this more and more and more, your spear
is going to get better, more reinforced.
It's going to be more capable. So that
in a nutshell is a good analogy for what
is really going on here, especially in a
self-nealing sort of situation. Why do
we do all of this? We do all of this to
reel in the inherently probabilistic
nature of large language models. This is
a diagram I just had a large language
model come up with actually. And
essentially on the left hand side is the
way that most people view these things.
And it's the reason why agents up until
quite recently haven't really been able
to be used in any sort of real business
scenario. This delivers an uncertain
outcome. And while it's a lot more
flexible, as you can see, these arrows
are sort of going all over the place.
Ultimately speaking, in a business, you
don't want flexibility. In a business,
you want determinism. You want a very
simple and easily interpretable list of
rules where if an input comes in here,
we route it based off of some filter
that we have. And so what we do is we
take the inherently flexible
probabilistic nature of LLMs and use it
to create a bunch of deterministic
pipelines and then it just calls the
specific pipeline that it wants while
making it better and better and better
over time. The last major point I'm
going to make is speed. The historical
way that you get things done by calling
LLMs with some sort of built-in tooling
like HTTP requests or whatever is very
slow. Okay. But when you use tools you
can go very fast. I mean, just as an
example, imagine if you fed a list of 10
items, okay, into some sort of LLM and
you said, "Hey, I want you to, I don't
know, uh, reverse sort this or something
like that." So, I basically want you to
take this list that's alphabetical and I
want you to do this. I want you to take
all the letters and I want you to
reverse them. If you did this within a
large language model, it would actually
have to calculate an enormously massive
matrix um you know series of arrays and
matrices in order to do the simple task
of just reversing or flipping this
array. Whereas if you created a specific
tool like in Python to do this, you
could do this virtually instantaneously.
The order of magnitude in the amount of
time it would take to do the top thing,
okay, using an LLM to bottom thing using
a tool is something like 10,000 times if
not 100,000 times. Not to mention you
also have no token usage making this
while not effective well not actually
free because you are going to be using
your CPU and and maybe some sort of
server if you want to host this
elsewhere it will be effectively free
compared to just how much time energy
and resources are being run in order to
do silly requests like this using LLMs.
So now that you guys understand at a
high level how the three layer software
architecture works, let me just run you
through what it'll look like exactly
within your integrated development
environment. Remember how earlier when I
were showing you guys the lead scraping
example, I um hid a bunch of the
additional folder structure and stuff
like that. The reason why is because
these are things that are specific to
the development environment that you're
using. But regardless of the development
environment you're using, you will
always have the following folders. Let's
just call this our workspace and just
pretend that this is up at the very top.
It's just like the big folder that
contains all the other folders. Okay.
The folders that you will need in order
to get this done in this way is you will
need some sort of directives folder and
then you'll also need some sort of
execution folder. Okay? And within
directives are going to live all of your
SOPs. So I don't I'm just going to call
this SOP1 MD. SOP2MD
over here within your execution folder
is going to live all of your
executables. So, I don't know. It'll be
Pi is just the ending of like a Python
script. Maybe it'll be, I don't know, enrich
enrich leads.py.
Now, we only have directives and
execution here. Notice how we don't have
the orchestrator. The reason why is
because the orchestrator is the LLM. And
the LLM sort of the thing you know the
big galaxy brain intelligence over here
that reads through the directives
associates them with specific
executables runs them okay so actually
executes these things in some sort of
terminal prompt and then it just loops
back and forth and back and forth over
and over and over again. If you can
understand what I've just put in front
of you here at least at a high level
without understanding any of the
programming concepts or anything like
that you can build a very good agentic
workflow. Okay, so that's the DOE or do
framework. Now directives are your SOPs.
These are the what that is the intent
the goal you know the rules of
engagement. Orchestration is your agent
which is the who. This is the decision
maker you know the router. And then
execution is your code which is the how.
And this is the reliable deterministic
machinery. It just runs the same every
single time. Very valuable for
businesses. By pushing the heavy lifting
onto those deterministic Python scripts
which is the execution and then keeping
the instructions really clear in
markdown which are directives. We let
the LLM do the one thing that it's
actually really good at which is being a
very intelligent router. That solves a
reliability problem, meaning your
scripts will run the same way basically
every time because a Python script does
not hallucinate. It either works or, you
know, it errors out. And if it errors
out, we can catch it. All your agent has
to do is decide when to run the thing.
Right now, the vast majority of Agentic
workflows are going to be built in
what's called an integrated development
environment or IDE. I've talked a little
bit about anti-gravity before and that
is beyond the purpose of our course. But
I am sure that future agentic workflow
builders will include dozens of
different input methods and ways to
build them that aren't in a terminal
style environment. But anti-gravity
isn't the only IDE available and I want
to run you guys through a brief little
laundry list here. What I'm going to do
next is I'm going to break down how most
IDs work just so you guys are familiar
with it from uh you know a bird's eye
perspective and then also a couple of
the tools we're going to be using and
then after that we're going to learn
self- annealing before we actually set
it up all in a real environment. By the
way, if you guys are already developers
or you understand how IDs work, you can
skip through the section and then move
on to the next one. And I should note,
I'm not going to be giving you guys an
academic or textbook definition of how
an ID works. We're just going to be
working through it from a very practical
perspective, aka what you actually need
to know in order to get out there and
build workflows and make money with
these things. If you guys want a much
more in-depth review, there are variety
of resources. Basically, every ID known
to man. Just search up the name of the
IDE and then the word tutorial and the
the service that built the system will
provide one. Okay, next up, I got a
brief walkthrough for you of a typical
integrated development environment. And
I'm going to do this for two idees. The
first IDE is this one over here, which
is anti-gravity. And the second IDE is
this one over here, which is called
Visual Studio Code. I wanted to show you
both because Anti-gravity is certainly
the newer hit on the block. Just
launched uh like within last week, I
believe. But Visual Studio Code has a
much bigger user base. A lot more people
are used to it. Regardless, you'll see
that the concepts are very similar and
they map basically one to one. Okay. So,
starting at the top left of
anti-gravity, as you see here, we have
that file explorer that I was
referencing earlier. This file explorer
is very similar to just the base file
explorer on your Mac or your PC. It's
just a way that you can organize files.
Now, in order to get to these files, you
do need to open a specific folder on
your computer. And so, if you've just
launched some sort of anti-gravity IDE
or maybe some sort of Visual Studio Code
thing, you actually do need to create or
open a folder in order to access what we
are seeing here. Okay. So in my case um
you know I opened up this workspace
folder and that's why I see what I'm
seeing on the lefth hand side. So within
that I have this aagent.claude.ve
and then I have my directives execution
tmp and this is just the course that I'm
actually recording for you guys right
now as well as some additional files.
The specifics of the files aren't very
important again because I want this to
be programming agnostic. Depending on
your background or whatever you will
know what some of these mean and you
won't. That's okay. I want you guys to
know that basically all of these were
done completely automatically. I didn't
actually like exert any control and
choosing the structure. This is just
something that the agent came up with
after reviewing you know effective
software architectures and stuff like
that. So the things that are ultimately
important for us are the directive
folder here and then the execution
folder here. Okay. So now that you
understand a highle overview just pay
close attention to a few things.
Different file types typically have
different sort of graphics and whatnot.
They also have different file um
endings. And so a markdown file, for
instance, if I click on my scrape leads
here, it has that little M with a down
and then it's a MD, right?
The Python script on the other hand,
you'll see changes a bunch of colors
within and then it has this little this
is supposed to be a Python with a pie at
the end. And so superficial information
here, but um you're already starting to
see there's significantly more structure
in code. It's almost like looking at a
rainbow versus looking at, you know, the
markdown uh directive. And that's just
because in code there are a lot more I
want to say like data types that you
need to keep track of. For instance,
green here are comments. You know, blue
might be variable definitions. Uh purple
might be some sort of logic and so on
and so forth. So, you don't actually
need to know any of this stuff, but when
most people are new to IDs and
programming and they download one of
these things and they start poking
around, they get really overwhelmed
because it just looks super complicated.
Okay, cool. So clearly what we do is we
select files on the left hand side here.
Then we open them in the middle. So
that's something that's worth taking a
look at. You have one open picker at a
time, but you could actually open as
many as you want. Just open to the side
this one, open to the side this one, and
so on and so forth, and it becomes
pretty cramped. You could use the same
sorts of hotkeys that you normally use
on, I don't know, like a Chrome instance
or something. So in my case, I just hold
command W, and then I can actually
delete open windows. That's pretty
useful. On the right hand side here,
moving over a bit, you see that there's
actually like a top level overview of
your code. This is marginally useful. I
believe this is like a VS code feature
initially and now basically every
platform has used it just because
sometimes you can go very very long with
these big big code files. So this just
allows you to see the architecture at a
glance and then I don't know quickly run
through and then find um specific point
in the code that you want. I don't
actually ever use this to be clear, but
I just want to be able to explain what's
going on under the hood so that if
anybody's super uh, you know,
intimidated, at least now, you know,
there's also up here a folder picker
which actually goes through and then
shows you the specific folders and then
more importantly the functions and the
classes um that you're in. And so I'm
actually within this fetch campaign
function here. If I go to get API key,
you'll see this now changes to get API
key. Pretty wild. Um, but this is more
or less what we're doing. We're creating
a folder that contains a file and within
that file are a bunch of subfolders
almost. It's just these are called
functions. Okay. Now, the good thing
about Python is it is pretty readable.
Not that you'll ever have to read it,
but it is pretty readable if you ever
did want to poke around. And when you um
add the right thing into your gemini.md,
which I'll cover in a moment, um it
actually comments the code reasonably
well. So, you can at least take a look
at some of the code if necessary in
order to get a high level understanding
of what's going on. For people here that
are more used to let's say no code
platforms like you know nad or make I
just want you to look at all function
definitions. So define get API key and
want you to just treat that like a
single node on a graph. That's basically
what it is. So this is your get API key
node and maybe this one here is your uh
fetch campaign node. You know this one
here is your extract sequences node and
so on and so forth. It's just instead of
it being nice and easy and visual left
to right. Obviously, this is laid out
sort of um top to bottom here in in
language that most people do not
understand natively. So, that's the main
drawback right now. But, as I mentioned,
future gen decoding platforms are almost
certainly going to all be drag and drop.
Now, in anti-gravity specifically, if we
go to this middle panel here, you'll see
that there are a couple of options. If
you hold command and E, you'll open your
agent manager. Your agent manager is
basically just like a one-off chat box
where you can talk to a model without
actually having to look through um you
know, all of your code and whatnot. I
mean, it'll still look through your
code, but this just basically takes
everything on the right hand side,
sticks it right in the middle. Then you
can do Q&A. You can do whatever the heck
you want with it, which is pretty nice.
You can also construct specific agents
for different purposes, which is kind of
neat. And you can even insert um
knowledge items into your uh
anti-gravity instance. So that if there
are things that you know you
specifically uh request pretty often
that a model wouldn't really know you
know eventually the model will actually
add that to a knowledge base so that'll
constantly be able to consult this
before answering your question. Up at
the top you have an inbox. That inbox
contains basically all of the
notifications that the agent has made
for you. This is something that's
anti-gravity specific and it's really
cool. I really like it. It's one of the
cool parts about this that I think a lot
of other IDs still have to catch up for.
And it's also a good example of these
platforms moving more towards like
agentic co-working than necessarily just
building in code. When you start a new
conversation, by default, you start it
in the playground. The playground is
just um a new conversation instance that
is not tied to any particular workspace.
But as you guys see here, you could also
open a specific workspace that you guys
have um discussed with a model before if
you want to. They also have the ability
to open new remote workspaces. So, this
opens up the possibility to do things on
other hardware later on, which is pretty
cool. There's also a browser use fate
feature. So, as you can see here, if I
click always allow, it'll actually go
and it'll request a specific um web page
that I've given it access to, and even
pull in things like DOM elements,
document object model for those you
unaware, that allow you to do cool
browser automations. This is my website
here, leftclick, and it's going through,
scrolling a page, extracting elements,
basically giving me a bunch of
information here. I just said, "Okay, go
to leftclick, tell me what's on it."
That's kind of neat. And if you're new
to this feature, just head to the bottom
lefthand corner of the agent manager and
you'll get everything that you need in
order to do that. We're not going to be
talking as much about that in this
course just because it is unfortunately
still sort of shaky. Only works maybe 70
80% of the time. Certainly not good
enough for real enterprise business
applications. But it is pretty cool and
kind of an indication of how quickly
we're soon going to be navigating um
most of the internet just using
browsers. Okay. On the left hand side of
the page, we also have a code search
feature. This is pretty neat because uh
instead of searching code, you can
actually just search in natural
language. So for instance, if I type the
word orchestration, you could see that
the top result is from a gemini.md file.
And this is a file where I give the
agent highlevel tople instructions to
basically guide it on what to do every
time it's initialized. I'll get into
that later, but essentially I can find
all instances of a specific word. So
this is obviously pretty useful if
you're searching across a large agentic
workflow base. This next feature here is
called source control. Now, I don't talk
much about source control in this video
or course because it's just not very
relevant to most people here that don't
have coding backgrounds, but essentially
there are ways that you can instantiate
what's called a repository, which is
just a way for you to store and then
control different updates of data. It's
very popular if you're a programmer
because it allows multiple people to
work on the same repository
simultaneously without screwing things
up, which as I'm sure you can imagine
tends to happen in old school um
software architecture where even like a
single semicolon at a place or whatever
could take the entire thing down. After
that, you have a run and debug tab. I
don't ever personally use this. Then
there's a remote explorer which is if
you do connect with a variety of other
servers or something like that, you can
actually show that information over here
which is kind of neat. After that you
have extensions. Extensions are pretty
popular. Um there are a variety of
different extensions for a variety of
different purposes. So you can download
docker markdown linting. You could do
go. You could do language support for
Java if you're using a different
programming language. These are all the
ones that I have installed over here.
And then down over here are ones that
are recommended to install. And then
finally you have testing down here at
the bottom. That little flask. I don't
really use this. Uh most of the time the
agent will construct its own test just
as part of the process. This is all
stuff that used to take software
engineers days in order to set up. Now
we do so with basically one button,
which is incredible. Okay, obligatory.
If you go to the top lefthand corner on
a Mac, you'll find some anti-gravity
settings up here. Pretty much the most
important feature here is this terminal
command auto execution and then this
review policy uh setting. Now, I'm sort
of accelerationist here. I just set both
of these to automatic. So top one's
always proceed, bottom one's turbo.
Essentially, uh, every time that the
model does something that would
typically require like a shell access or
terminal access or create something for
you, um, you have the option to have it
ask you whether or not you'd like to
review it or autonomously proceed. Now,
I want my system to do all the work for
me. Obviously, I don't want to have to
be checked in with every 5 seconds. Uh,
and so I just set all of these to
autonomously proceed. And I find that
when I do, that's when the real leverage
kicks in. If you think about Visual
Studio Code back in the day, sorry I say
back in the day here, we're talking like
a couple of months with um Cloud Code or
whatever, one of the most annoying
things ever to me was how I would ask it
to do something and then I'd step away
for a few minutes and I'd come back and
I'd realize that 5 seconds after I ask
it to do something, it ask me to
doublech checkck a review before it
continued. That's a lot of wasted time.
And so I trust most of these models in
their inherent judgment so long as I
give them good enough framework to
manage. Um, so I typically set review
policy and terminal command auto
execution both to on. I should note
there's some security issues with this.
Veteran programmers, comps science
security people will probably look at me
and be like, what are you crazy? But
we're entering a new era where agents
that tend to have significantly more
autonomy are significantly more
productive. And I'm happy to make that
trade-off. And that's a walkthrough of
anti-gravity. Okay, opening up Visual
Studio Code here. I'm going to do this
at a very high level because hopefully
you see things are pretty similar. You
have a file explorer over here. So we
have our folders, directives, and
execution ones. Okay, there's an open
editors page here, which if I had other
editors open, I would be able to see
them. If I want to click on a file,
instead of opening in the middle, it
opens on the right hand side, and that's
okay. Reason why is because I just
haven't opened up my little claude code
or terminal or aentic workflow instance.
So sort of rearranges to look more
similar to what you guys are used to.
Now, typically what you actually have to
do in order to get this thing to run is
you um need to have an agentic platform
like cloud code installed in your VS
Code. doesn't really come natively or
ship natively out the box although I'm
sure uh you know cursor and and other
platforms and stuff do. So in my case
this is now the interface for cloud code
and I can talk to it just like I would
talk to the agent inside of
anti-gravity. Super straightforward. I
just find unless you specify that you
want to see more thinking it's not going
to show you more thinking which can be a
good or a bad thing if you'd like. Aside
from that basically everything here is
the same. Okay just different UX. Left
hand side you have your search tab you
have your source control tab. This is
your run and debug tab. Here are your
extensions. There's your remote
explorer. There's some agent sessions
here, which is a local chat agent. This
is VS Code trying to basically compete
or do things like cloud code. You have
your tests down here. Then finally, you
have um this is a custom extension I
built called Cloud Code Chat, which
basically just does the same thing as
what you guys are seeing on the right
hand side of the page. So, we're only
seeing this here because Aenta coding is
still pretty new, right? And so, people
haven't really figured out one final
convention for it all. That's why you
see slightly different layouts and UX's
and stuff like that. Awesome. You guys
now know everything you need to know
about an ID in order to build cool
agentic workflows. Let's move on. All
right, so you guys now know the ins and
outs of most idees. Congratulations.
Let's move on to self- annealing
workflows. So in metallurgy, which is
basically the process and production of
metals. Annealing is a process where
you'll heat the metal and then you will
slowly cool down the metal to remove
internal stresses and make it stronger.
if you guys are really into animes, but
tons of old school animes where some
dude dips a steaming hot sword in a big
thing of water come to mind when I say
this. And basically, the heat allows the
atoms to arrange themselves into a more
stable structure. In the context of AI,
self-annealing means building a system
that gets stronger every time it fails.
So, think about that for a second. Most
automations that were built before this,
whether it's in code or using a drag and
drop platform like maker or nadn, you
know, if an error occurs in your
scraper, let's say a button that you
were scraping on a website moves or
maybe the API figures out that you're
scraping and it starts returning a 429,
which is a rate limiter, your automation
will crash, the process will die, and
then you will lose a lot of money. But
in a self- annealing workflow, these
systems are anti-fragile. And I'm
borrowing that term from this lovely
writer called Nim Taleb, if you guys
didn't know. It's a great book. But to
make a long story short, anti-fragility
basically means a system benefits from
shocks. Just like the sword being dipped
in cool water, that sword benefits from
the shock. And in the same way, our
systems will benefit from errors. In our
case, if an error occurs in the agent, a
self annealing framework means it will
not crash. It will instead pause. It
will read the error message and then it
will look at the code that caused the
error and then hopefully it will fix it.
And then most importantly, it'll even
rewrite both the script to handle the
new edge case and then the directive or
the series of instructions to warn
future instances about the rate limit
and assure that it'll be able to handle
it moving forward. Then it'll try again
and then it'll work. So that is the
difference between a tool like maybe an
NAN or make.com workflow that you
constantly have to babysit for errors
and then what we are moving to which is
the idea of an AI employee. Now in real
life, an employee that comes to you
every time they hit a roadblock is super
annoying, right? And I know this from
experience. have had many of the sort,
but an employee who runs into an error
and then has the ability to figure out
the error, then go back into the company
SOP database and update it so nobody
else hits the roadblock and then maybe
run an educational session teaching
everybody else in the company how to
avoid it as well is a freaking star
player and those are people you want to
keep on hand. So we are going to
implement a feedback loop where your
agent has the permission and capability
to rewrite its own directives and its
own execution scripts based on real
world feedback. This is the secret
sauce. This is how you build a system
that you guys can leave running for
weeks. Then when you come back, it's
actually running better than when you
left it. Let's see how this works in
practice. Okay, so just before we
actually build in the very high level
directive that allows our agent and
encourages it to be self- analing, let
me just show you a brief visual
demonstration of the concepts I was
talking about earlier. So in metallurgy,
we have a bunch of these chaotic atoms.
Then we hit some sort of annealing
flame, dump it into some sort of cold
liquid, and then we get a beautifully
aligned crystal lice. This actually
happens in nature. I want you guys to
think of our systems very similarly. We
start out with some code that actually
may or may not be very good. I mean,
these AI systems have been known to cut
corners wherever humanly possible for
tokens saving reasons or for a variety
of others. But the reality is we
shouldn't just trust the code that comes
out the very first time. What we need to
do is we need to stress test it. And so
you can think of the stress testing as
basically being a failure filter where
we have all these lines sort of going in
all these different directions and we
just filter them. What ends up coming
out is an efficient protocol. That's
what we're looking for realistically
with a self annealing system. Another
way of looking at it is day one you have
some very rough highlevel bullet
pointbased directive of what it is that
you want to do. Okay? And I don't know
we're just graphing this basically but
we just want it to go up and then go
down and then go up again. Okay? This is
our rough directive. The very first time
that we run it might work I don't know
20 30 40% of the time or something like
that. What happens when it fails though
is we start fortifying and if you build
self annealing into your agent, it will
start doing things like adding automatic
retry logic at specific points, adding
some sort of validation step at other
points and so on and so forth to turn
something that might just look like a
little dainty piece of string into
something that is extraordinarily
effective, efficient and then a lot
safer than it was initially. So that's
what we are going to be doing. Now how
do you actually do this? I talked about
in our um editor how we'd start out with
a directives folder that we'd also start
out with an executions folder, right?
Well, all IDE integrated development
environments have one additional piece
of data that you can add to the agent
that allow this to work about as well as
you know I'm talking about here. And if
you don't have this initial prompt,
initial uh sort of highle guidance,
performance tends to be significantly
worse than if you have it. So my
recommendation is have it. What this is,
this is basically an injected prompt
that you always add or the system will
always add at the beginning of a whole
conversation chain. And the way that
this works is you define a file and
there are a variety of different
conventions for these files. One is agents.md.
agents.md.
Another for claude codebased systems is claude.md.
claude.md.
One for gemini based systems is
unsurprisingly gemini.md. Okay. Variety
of these different conventions depends
on the ID that you're using. And you
just give it one time an initial highle
overview of what you expect from it. So
that right off the bat, starting from
the very first prompt, sort of like your
system prompt if you guys are used to
using that. um it always knows sort of
like the the the structure of your
framework and it understands what it
means to be self- analing. If you guys
offer this, this is like steering the
ship. And if you think about it, I mean,
this is just a rough little map here. If
I'm on uh I don't know, say that this is
the east coast of the uh United States
and this is somewhere on like the west
coast of Africa or something like that.
If I'm over here, okay, and I have a
little ship
and you know, my goal is to go over
here, let's say there's some port,
right? If I give myself even a slight
range of possible outcomes,
I might greatly overshoot where this is.
I mean, I could end up anywhere from
here all the way up to like here to like
here to here. So, what we do is at the
very very beginning stages, basically
about as early on as humanly possible,
we constrain
where that ship can go within very tight
guard rails. So the probability of it
going somewhere that we don't want it to
go is very very low. Okay. Viewed
another way because we're going to be
doing some very big long things with
this agent. It's very important that we
get it started on exactly the right
trajectory. Which is why I always
recommend having some sort of file like
this. What does this file actually look
like in practice? Well, if you guys were
keen, you'd notice in my anti-gravity
environment, I had this at gemini.md.
And this is what is now injected at the
beginning of every single instantiation
of my agent. So what we do is we put
very highle instructions just describing
what our environment is, how the DO
framework works and what we expect from
the agent in terms of you know its
ability to self- anneal. So if I zoom in
here a little bit, you can see that I'm
saying hey you operate within a three
layer architecture that separates
concerns to maximize reliability. LLMs
are probabilistic whereas most business
logic is deterministic and thus requires
consistency. The system fixes that
mismatch. Three layer architecture layer
one directive what to do. It's SOPs
written in markdown that lives in
directives. So I'm actually telling it
where they are. Defines the goals,
inputs, tools and scripts to use outputs
and edge cases. Natural language
instructions like you give a mid-level
employee. Layer 2's orchestration. This
is you. Your job is intelligent routing.
You read directives, call execution
tools in the right order, handle errors,
ask for clarification, and update
directives with learnings. You are the
glue between intent and execution. Eg.
You don't try to scraping websites
yourself. You read directives/scrape
website and come up with inputs,
outputs, and then run execution scrape
single site. Finally, we have our
execution layer. These are deterministic
Python scripts and execution environment
variables, API tokens, etc. are stored
in env. That's this other file over
here. It's a programming convention, but
basically rather than store all of your
API keys in plain text, you just put
them in one place so you never misplace
them. Handle API calls, data processing,
file operations, database interactions,
reliable, testable, and fast. Use
scripts instead of manual work. We give
it some logic as for why. And then comes
the self annealing. So you should
self-anneal when things break. Read
error message and stack trace. Fix the
script and test it again unless it uses
paid tokens, credits, etc. In which
case, you check with user first.
Definitely have something in there.
update the directive with what you
learned. An example is right over here.
And then finally, I actually give it a
brief little self-ining loop. So you fix
it, you update the tool, test the tool,
update the directive, and now the system
is stronger than it was before. This is
something that you need in order for
your agent to have context over how the
system works. I'd always recommend
having something along these lines
stored in a high level either agents MD,
claude MD, Gemini.m MD, but obviously
look up the convention of your
particular IDE. um this is just
something that needs to be in the
background 24/7 otherwise your agent can
figure this out and you know it'll try
its best too but you can just run into
silly initial logic where I don't know
you say hey do this thing and then it'll
check out your executions folder it'll
find something called the thing that you
want to do and then it won't realize
there's actually a highle series of
directives that guide it so this is a
much quicker and easier way just to
ensure it always gets off on the right
foot so that's the power of self
annealing you guys are no longer just
writing code you're basically creating
almost a living system You will start
with a rough SOP. The agent will then
try to execute it. It will then hit a
snag. It will then fix the snag. It'll
update the SOP, optimize the code, and
over time, the directive that you wrote
will evolve from this really rough sort
of bullet point sketch into hopefully a
significantly more reliable, very
optimized protocol that allows you to
handle edge cases that you probably
didn't even know existed when you
started. I have workflows that have been
running for weeks now that I haven't
touched at all. But if I look at the
code today, it is very different from
the code that we had initially. You
know, it's added different retry logic.
It's added tons of validation steps.
It's come up with like weird edge cases
or catch errors that I didn't realize.
It swapped out one-off end points for
bulk endpoints. It's optimized for speed
and reliability. And the cool thing is
the agent did all that. I had absolutely
nothing to do with it. So you have the
theory, you have the architecture, and
you also now have the self-improving
mechanism. Let's get our hands dirty to
actually build some stuff. So as we all
know, theory is useless with that
execution. Time to build some workflows.
You guys can technically build any of
these in VS Code or a cursor or even a
notepad if you are super masochistic.
But let me show you how I actually build
these things from scratch. I will start
by configuring a list of core
instructions for the model. Then we will
set up a goal. I will give it some
bullet points. Then it's going to craft
its own directives and its executions.
Okay. So I have anti-gravity open here.
And what I want to do is I want to show
you guys how to set it up completely
from scratch. Assuming that you're
starting at the exact same place that I
am right now. So when you open up
anti-gravity, this is what it'll look
like. First thing you need to do is
obviously find a folder or a workspace.
I'm on Mac OS. So all I'm going to do is
just click new folder. I'm going to call
this example workspace. Then I'm going
to click create. Once I'm inside of
example workspace, and this is really
important, you have to be inside of the
folder. You click open. Now you have
your workspace open inside of
anti-gravity. And the very first thing
we want to do is we just want to drop a gemini.md
gemini.md
at the top level of the folder
structure. Then you want to paste in
these descriptions which I showed you
guys earlier on in the video. Of course,
once you're done with this, you've saved
it, you could say instantiate my
environment based on what's in Gemini.
MD. So, we're basically instead of
having to make all these folders and
everything like that on our own, we're
just going to have Gemini do it for us.
Odds are, you know, we've given it all
the information that it needs in this
file. So, it's going to go through and
then, you know, set up some folders and
that sort of thing. Okay, it's gone
through and created a directives folder
up top with an execution folder
underneath. It's also created a git
ignore folder assuming that we were
going to create a GitHub workflow or
repository for this. Although I'm not
going to be uploading to GitHub just for
the purposes of this demonstration. And
now it's just going through to see if
there's anything else. Presumably it's
writing a readme that just explains sort
of what's going on, how the workspace is
structured and stuff like this. Again,
all just classic things that you would
find in some sort of um GitHub workflow.
Okay, now that we're done with that, now
that we have our directives folder and
our execution folder, what we want to do
is we want to start creating workflows.
So very first thing I'm going to do is
I'm just going to ask it to do some very
very simple workflow for me similar to
the workflow that you saw in one of my
examples. I'm going to ask it to scrape
some leads for me uh with some highle
bullet points and then uh it's going to
guide me through the actual creation of
said workflow. Okay, I have my
instructions right over here.
Essentially what I'm saying is I want to
create a workflow that scrapes leads in
an industry I specify using a specific
Apify actor. All I did was I went on to
Ampify, which is this big scraping
marketplace, and then I just found one
of the actors here that worked for me.
Then I say add to a Google sheet and
then then finally I say give me a link
to review. So all natural language
instructions very high level. As part of
the scrape I first want you to scrape a
test run at 25 leads. Then I want you to
verify how many of them are in my
initial industry. Sometimes lead to
scrape that are outside my scope. Just
how filters work. If 80% or more of the
leads are okay proceed with scraping the
full amount. If less than 80% are okay.
Retry with different filters. So I'm
giving this entirely autonomously to um
Gemini 3 Pro high. And I'm just letting
it run. So, this is going to occur in as
close to real time as possible. I'm
going to cut out any prolonged waiting
times like when we run the Appify
scraper a couple of times as a test, but
you can see that it's um initially set
me up a workflow implementation plan.
And this is just an internal thing that
systems nowadays always do just to
improve their accuracy. They basically
use this as like a checklist of tasks
that they do. One thing we can see right
here is that it's ensuring it's asking
me rather to provide an Appify API token
and then also a service account for
Google Sheets access. So, I'm going to
need to go on my end and actually
provide it some access, but I'm trusting
that it will know that it does not have
set access and it will guide me through
the process of adding it. What's really
cool is that it's fully autonomous. It's
doing all of this entirely without any
sort of overview, just based off of my
initial ask. Okay. And as you guys can
see, it's now created a first draft of
my directive. The directive is basically
just an expanded version of the bullet
points that I provided. But we have the
goal, the inputs, the tools and scripts,
process, outputs, edge cases, and then
some error handling as well. And then if
I go down to the actual Python script,
you have the scrape_appify, then the
update underscore sheet. So we have two
different ones here. One is specifically
for amplify. It's a temporary script
that it's created for that purpose. And
the other is for the the Google sheet.
So we're not relying on the model to do
the logic for us. We're just having it
build the function. Do I know what this
is doing? No, I have no idea. I've never
even looked at this thing. Some people
would probably consider that a security
error. And you know, any computer
security people here, um, that probably
is a security error, but that's just how
agents are. They're just building things
extemporaneously for you. They're
abstracting away all of the complexity
and then you get to use it as a business
partner essentially. Okay, it's asking
me for Appy and Google credentials now.
So, I'm just going to go and find some
really quickly. Heading over to Appify
down at the I believe it was bottom
left. I have settings, then API and
integrations. And why don't I just
create a new one here? Let's actually
have that expire tomorrow so nobody
screws with me. First, I'm going to
paste that in. Okay. And I provided both
the API key and then a bunch of Google
details as well. Okay, it's now doing a
bunch of integration. It's found
presumably some errors with the
authentication token I provided and then
um I don't know somev file here which
contains all of my credentials. I'm just
going to leave this let the model do its
thing and I'll worry about actually
testing this thing when it's done. And
it's now saying it's configured my
credentials and updated the workflow to
support ooth. When I run the scrape for
the first time it'll uh print a URL. I
just need to open it in my browser.
Okay, test.
Let's do 100 I don't know dental leads.
Let's see what happens. Now remember in
a self annealing workflow the very first
time you instantiate something it is the
weakest it will ever be because it has
not actually gone through and you know
done any edge cases or anything. It's
been just a few minutes since I started
this. So probability of the model having
figured everything out right now is
pretty low. But that's the benefit of
the self analing workflow. I'm just
going to ask it to run a test. It's
going to go do all of the testing. It's
presumably going to run at some errors.
Who knows? Might oneshot it. And if it
does that's fantastic. Looks like we
have actually already gone through and
started scraping which is quite nice.
Um, but as we accumulate errors and as
these errors occur, the only real cost
on our end is a few additional seconds,
maybe 10 to 15 seconds while we wait for
it to rectify itself and then our
directives just get stronger and more
fortified over time. Another thing you
can do just to get more visibility into
what's going on is you can just move the
terminal session down here to the bottom
of the screen. I'm hiding the leftmost
side of it, but essentially that's just
saying um, you know, nyx arrive at
MacBook Pro or whatever. So don't worry
too much about that. But anytime you run
any sort of console or uh terminal
thing, it's just nice to be able to see
it actually occur live down here. And
the benefit is when some issue occurs,
you know, it's not in this little tiny
window. I can actually direct the agent
and let it know, hey, you know, I'm
running into some issue with the lead
scraping filter or whatever. And right
off the bat, I'm seeing we're just
scraping too many leads. So, you know,
we're going over the 25 mark. I think
we're at 200 now. Hey, you're scraping
more than 25 leads. So, I just entered
the request essentially guiding it
saying, "Hey, there's something weird
going on. you scraped more than 100
leads. To be clear, I didn't need to do
this. It would eventually figure this
out on its own, but I figured if I could
save myself 30 seconds now, might as
well. Looks like it figured out the
issue. It's now rerunning the scrape
with a strictly enforced limit of 25
leads. One cool thing that Gemini will
do is it will wait for command
completion up to a pre-desated amount of
time. In this case, it's basically
checking every 30 seconds to see how
many of these leads we've scraped and
stuff like that. So, it's almost like an
internal weight. If you guys are familiar with make or nadon, um, what's
familiar with make or nadon, um, what's cool is it just creates the weights on
cool is it just creates the weights on its own. So if you have a process that
its own. So if you have a process that it knows is going to take a fair amount
it knows is going to take a fair amount of time to scrape in this case ampify is
of time to scrape in this case ampify is the obviously a limiting factor here can
the obviously a limiting factor here can only run as much as the server uh space
only run as much as the server uh space and RAM and stuff like that allotted to
and RAM and stuff like that allotted to it. It will actually intelligently try
it. It will actually intelligently try and check in at certain amounts of time.
and check in at certain amounts of time. So that's what it's doing right now.
So that's what it's doing right now. Okay. And it's actually gone through and
Okay. And it's actually gone through and then generated me a big JSON with all of
then generated me a big JSON with all of the lead information right here which is
the lead information right here which is pretty cool. Um as you can see here we
pretty cool. Um as you can see here we don't just get the email address, the
don't just get the email address, the first name, the last name. We get stuff
first name, the last name. We get stuff like all the keywords, we get the phone
like all the keywords, we get the phone numbers. we get the headlines and so on
numbers. we get the headlines and so on and so forth. So pretty good as a first
and so forth. So pretty good as a first pass. Now let's make it better. Now I
pass. Now let's make it better. Now I should note that while it is building
should note that while it is building said workflow, this is a process that
said workflow, this is a process that takes a few minutes. You can just step
takes a few minutes. You can just step away and you can do whatever the heck
away and you can do whatever the heck else you want. You can actually have
else you want. You can actually have multiple anti-gravity instances
acceleration card. No way. That's wild. And it's an example of like an actual
And it's an example of like an actual agent, you know, doing a claims
agent, you know, doing a claims processing thing. Hm. You know, lot lot
processing thing. Hm. You know, lot lot that I could do there. Maybe I could
that I could do there. Maybe I could make videos on that. This is on a voice
make videos on that. This is on a voice agent, right, with Gemini 3 Pro. I mean,
agent, right, with Gemini 3 Pro. I mean, I could see that as an opportunity.
I could see that as an opportunity. Yeah. Anyway, I guess what I'm trying to
Yeah. Anyway, I guess what I'm trying to say is I'm trying to demonstrate that
say is I'm trying to demonstrate that these flows can actually already be
these flows can actually already be pretty useful. I'm just as is. Okay.
pretty useful. I'm just as is. Okay. Okay, I'm just going to go and press one
Okay, I'm just going to go and press one for all URLs that are fetching. Now,
for all URLs that are fetching. Now, what it's doing is it's actually running
what it's doing is it's actually running through the websites themselves to
through the websites themselves to verify whether or not they are in the
verify whether or not they are in the target market that I want. And it's just
target market that I want. And it's just going to continue doing this over and
going to continue doing this over and over and over again until it gets me the
over and over again until it gets me the list that I'm looking for. Meanwhile,
list that I'm looking for. Meanwhile, bottom list looks pretty good.
bottom list looks pretty good. Theoretically, I mean, I could scrape
Theoretically, I mean, I could scrape like 30 of these simultaneously if I
like 30 of these simultaneously if I wanted to. I could have the agent, you
wanted to. I could have the agent, you know, verify the results of one and then
know, verify the results of one and then do another. I could have five different
do another. I could have five different agents here simultaneously generating uh
agents here simultaneously generating uh copy and customizing them to send to
copy and customizing them to send to other people. The possibilities here, at
other people. The possibilities here, at least for an outbound business like
least for an outbound business like myself, really are endless. [gasps] But
myself, really are endless. [gasps] But let's say, you know, I have some sort
let's say, you know, I have some sort of, I don't know, proposal that I need
of, I don't know, proposal that I need to generate or whatever, right? I
to generate or whatever, right? I haven't actually created any Python
haven't actually created any Python scripts or directives that specifically
scripts or directives that specifically generate proposals, right? Haven't done
generate proposals, right? Haven't done any of that stuff yet. What I'm going to
any of that stuff yet. What I'm going to do is I'm going to go into my other
do is I'm going to go into my other workspace where I have these proposal
workspace where I have these proposal generators and I'm just going to copy
generators and I'm just going to copy over the directives and then the Python
over the directives and then the Python files into this one and then I'm going
files into this one and then I'm going to run them. Let me show you what I
to run them. Let me show you what I mean. First, I'm going to open another
mean. First, I'm going to open another window. Then I'm going to open the
window. Then I'm going to open the folder that I was working at last week
folder that I was working at last week called workspace. I'm going to head over
called workspace. I'm going to head over here to directives in my old workspace.
here to directives in my old workspace. And if you guys remember, there was a
And if you guys remember, there was a create proposal.md file. I'm just going
create proposal.md file. I'm just going to duplicate this and move the directive
to duplicate this and move the directive over here. This works the exact same way
over here. This works the exact same way as templating features in like make.com
as templating features in like make.com or NAD. It's just I'm literally sending
or NAD. It's just I'm literally sending over natural language. So the
over natural language. So the probability of there being some issue
probability of there being some issue here is a lot lower. Imagine if you
here is a lot lower. Imagine if you could duplicate an NAD file and then
could duplicate an NAD file and then copy and paste that into a make.com
copy and paste that into a make.com environment. Would open up a ton of
environment. Would open up a ton of flexibility, right? Okay. So I believe
flexibility, right? Okay. So I believe let me just check the directive itself
let me just check the directive itself for the create proposal. What did we
for the create proposal. What did we use? If I just gopy h looks like it was
use? If I just gopy h looks like it was create_proposal.py.
create_proposal.py. So I should be able to do everything I
So I should be able to do everything I need just by copying pasting this over
need just by copying pasting this over here. And now I have this in my new
here. And now I have this in my new workspace which is fantastic. So what
workspace which is fantastic. So what I'm going to do here is I'm going to say
I'm going to do here is I'm going to say hey I'd like to generate a proposal. The
hey I'd like to generate a proposal. The company is called 1 second copy. Their
company is called 1 second copy. Their main problem is they are currently
main problem is they are currently manually generating leads by assigning u
manually generating leads by assigning u virtual assistants from lower cost of
virtual assistants from lower cost of living countries to scrape various um
living countries to scrape various um lead databases and manually on LinkedIn.
lead databases and manually on LinkedIn. They're currently spending somewhere
They're currently spending somewhere between $5 to $10,000 a month on this.
between $5 to $10,000 a month on this. Our service uh costs equivalently for
Our service uh costs equivalently for the same number of leads that they're
the same number of leads that they're generating per month, which is $3,000
generating per month, which is $3,000 leads a month, less than $500. So large
leads a month, less than $500. So large cost savings there. But more
cost savings there. But more importantly, it solves the opportunity
importantly, it solves the opportunity cost of how many of their resources are
cost of how many of their resources are tied down uh into lead genen as opposed
tied down uh into lead genen as opposed to things like setting, sales, uh
to things like setting, sales, uh onboarding, and so on and so forth.
onboarding, and so on and so forth. Total cost of our service for this would
Total cost of our service for this would be $12,000 in month 1, 8,500 in month
be $12,000 in month 1, 8,500 in month two, and 6,500 in month three. Create a
two, and 6,500 in month three. Create a proposal.
proposal. Okay, so no context on what any of these
Okay, so no context on what any of these directives or executions are. What it's
directives or executions are. What it's going to do though is it's immediately
going to do though is it's immediately going to read through all of these.
going to read through all of these. After it finds the create proposal um in
After it finds the create proposal um in the execution level, it's then going to
the execution level, it's then going to search automatically for proposal. These
search automatically for proposal. These two stars mean anything to the left and
two stars mean anything to the left and to the right of it in the directives
to the right of it in the directives folder to find the according directive.
folder to find the according directive. So get that information and then it's
So get that information and then it's just going to do a brief little double
just going to do a brief little double check here as part of the directive. So
check here as part of the directive. So what do I need from you? Client contact
what do I need from you? Client contact info, right? So Nick Sarif, we'll do
info, right? So Nick Sarif, we'll do Nick@nicks.com.
Nick@nicks.com. Turn this into four problems. Also
Turn this into four problems. Also company is 1 second copy. Cool. All
company is 1 second copy. Cool. All right. Now on the bottom here, it looks
right. Now on the bottom here, it looks like we've actually already generated
like we've actually already generated the list of 2,000 leads. That's pretty
the list of 2,000 leads. That's pretty cool. I'm just going to make this a
cool. I'm just going to make this a little bit smaller so I can see them for
little bit smaller so I can see them for myself. Looks like we have a lot of the
myself. Looks like we have a lot of the 2,00 emails, which is huge. Okay, that's
2,00 emails, which is huge. Okay, that's pretty cool. Uh, if I go back here to
pretty cool. Uh, if I go back here to the top, what's what's going on here?
the top, what's what's going on here? Looks like it's still doing the scrape.
Looks like it's still doing the scrape. And what this actor did, because there's
And what this actor did, because there's significantly more difficulty in, you
significantly more difficulty in, you know, finding something as illdefined as
know, finding something as illdefined as high ticket SAS, right? Like it needs to
high ticket SAS, right? Like it needs to do a lot more work. It's actually
do a lot more work. It's actually attempting an approach where it runs
attempting an approach where it runs four parallel scrapes across multiple
four parallel scrapes across multiple different regions to find a lead list.
different regions to find a lead list. That's pretty wild. It also looks like
That's pretty wild. It also looks like it's gone through killed a bunch of
it's gone through killed a bunch of shells, created a filtering script with
shells, created a filtering script with a 44% pass rate on test data. And its
a 44% pass rate on test data. And its goal is now it's going to get between 7
goal is now it's going to get between 7 to 9,000 leads total with a 44% filter
to 9,000 leads total with a 44% filter rate to give 3 to 4,000 quality SAS
rate to give 3 to 4,000 quality SAS leads, which meets our 3,000 target.
leads, which meets our 3,000 target. Okay, so since I've set this to auto
Okay, so since I've set this to auto run, it's automatically running. Here
run, it's automatically running. Here it's going. And it's also running like
it's going. And it's also running like its own little sleep script. So every
its own little sleep script. So every 120 seconds it just checks back in. This
120 seconds it just checks back in. This agent is asking me if everything here
agent is asking me if everything here looks accurate, if it can go ahead and
looks accurate, if it can go ahead and proceed with creating the proposal. I
proceed with creating the proposal. I don't really like that it's asking me
don't really like that it's asking me that question. So I'm just going to say
that question. So I'm just going to say update directive to preclude asking me
update directive to preclude asking me for permission. Instead just run just
for permission. Instead just run just assume I want you yes we can generate
assume I want you yes we can generate this to generate. Okay. So it's need to
this to generate. Okay. So it's need to find a pandock. Ah yes that's something
find a pandock. Ah yes that's something that I'm missing for sure. So, I'm just
that I'm missing for sure. So, I'm just going to head back to my other workspace
going to head back to my other workspace and add that in. Let me tell it updated.
and add that in. Let me tell it updated. It's now good to go. Cool.
It's now good to go. Cool. It's now going to go and create, which
It's now going to go and create, which is nice. [sighs]
is nice. [sighs] Meanwhile, you know, we've done a fair
Meanwhile, you know, we've done a fair amount of work here with these
amount of work here with these recruitment companies, but I want to go
recruitment companies, but I want to go a little bit further. I mean, why is
a little bit further. I mean, why is there an agent just sitting around not
there an agent just sitting around not doing anything productive, right? Why
doing anything productive, right? Why should I allow that to occur? What I'm
should I allow that to occur? What I'm going to do instead is I'm going to head
going to do instead is I'm going to head over here to the directives and I'm also
over here to the directives and I'm also going to duplicate the let's see the
going to duplicate the let's see the casualize company names and then the
casualize company names and then the casualized company names batch endpoint
casualized company names batch endpoint here too. I'm then going to paste this
here too. I'm then going to paste this in. I'm realizing here that I can't
in. I'm realizing here that I can't paste both these into the same folder.
paste both these into the same folder. I'm going to head down here and I'll say
I'm going to head down here and I'll say great work. Now casualize these company
great work. Now casualize these company names. As you guys can see, when you use
names. As you guys can see, when you use something like claw code for this, um
something like claw code for this, um the constant permission asking is kind
the constant permission asking is kind of a pain in the ass, right? Ideally,
of a pain in the ass, right? Ideally, you would have all this stuff occur
you would have all this stuff occur totally autonomously with absolutely no
totally autonomously with absolutely no permissions or anything like that. That
permissions or anything like that. That said, you know, as you scale up and you
said, you know, as you scale up and you start organizing and and working and
start organizing and and working and orchestrating more of these agents
orchestrating more of these agents working simultaneously, um you do need
working simultaneously, um you do need some sort of check and balance to make
some sort of check and balance to make sure that it's not doing things that,
sure that it's not doing things that, you know, you don't want to do. Okay,
you know, you don't want to do. Okay, I'm now going to see if we could send an
I'm now going to see if we could send an email. That's pretty cool. It's then
email. That's pretty cool. It's then going to send me some notifications. I
going to send me some notifications. I should note there's no execution script
should note there's no execution script for um the directive. So ideally we'd
for um the directive. So ideally we'd have an MCP that would do that. So what
have an MCP that would do that. So what I can do is I can actually go back into
I can do is I can actually go back into Claude and I can get my MCP.json.
Claude and I can get my MCP.json. So I'm going to copy this over head and
So I'm going to copy this over head and over here to Claude. I'll paste this in.
over here to Claude. I'll paste this in. Okay. And I'm taking a look at this
Okay. And I'm taking a look at this proposal now. Let's see how good of a
proposal now. Let's see how good of a job it did.
job it did. Nice. Good job little AI worker. So we
Nice. Good job little AI worker. So we scroll down here. We see you're spending
scroll down here. We see you're spending between 5 to 10,000 per month on virtual
between 5 to 10,000 per month on virtual assistants to manually scrape lead
assistants to manually scrape lead databases in LinkedIn. your team's time
databases in LinkedIn. your team's time and attention is being consumed. Manual
and attention is being consumed. Manual lead scraping introduces human error and
lead scraping introduces human error and your current system requires hiring more
your current system requires hiring more VAS. As you can see here, there's
VAS. As you can see here, there's there's there's one thing to build these
there's there's one thing to build these systems and it's another thing entirely
systems and it's another thing entirely to use these systems. And so what I'm
to use these systems. And so what I'm doing here is I'm showing you that you
doing here is I'm showing you that you can build very effective systems in a
can build very effective systems in a very small period of time. And then this
very small period of time. And then this isn't all just academic. It's not
isn't all just academic. It's not theoretic. What you can do is you can
theoretic. What you can do is you can actually just start using these things
actually just start using these things on your own in your own workspace super
on your own in your own workspace super easily. So, I have these u three agents
easily. So, I have these u three agents doing the equivalent of several hours of
doing the equivalent of several hours of work for me in literally just a couple
work for me in literally just a couple of minutes. Okay. And then finally, I
of minutes. Okay. And then finally, I see it's asking me to set up a Gmail
see it's asking me to set up a Gmail sending the script/mcp server and then
sending the script/mcp server and then copy the HTML content send manually. I'm
copy the HTML content send manually. I'm actually just going to have it do it
actually just going to have it do it automatically. If you guys didn't know,
automatically. If you guys didn't know, um you can set up MCPS uh pretty easily
um you can set up MCPS uh pretty easily here. What I'm going to do is I'm just
here. What I'm going to do is I'm just going to have it reference that
going to have it reference that MCP.json. The way that I do this is I'm
MCP.json. The way that I do this is I'm going to go new conversation. I'm going
going to go new conversation. I'm going to check MCP status. Okay. Okay. And
to check MCP status. Okay. Okay. And while I'm at it, I see that we've now
while I'm at it, I see that we've now assembled a list of 3,000 highquality or
assembled a list of 3,000 highquality or high ticket SAS owners. This is pretty
high ticket SAS owners. This is pretty cool. Really excited to see how high
cool. Really excited to see how high quality these leads are for a campaign
quality these leads are for a campaign that I'm running. Let's just make it so
that I'm running. Let's just make it so we can see all of these rows. That's
we can see all of these rows. That's pretty cool. Of the 3,000, we got 2,970
pretty cool. Of the 3,000, we got 2,970 emails, which is just pretty wild. Um,
emails, which is just pretty wild. Um, I'm also going to ask it to casualize
I'm also going to ask it to casualize company names.
company names. So that way we get a oneline casual
So that way we get a oneline casual company name. And I'm just going to
company name. And I'm just going to check the performance of the other one
check the performance of the other one here. Moving all the way to the right.
here. Moving all the way to the right. Looks like it took uh the word, you
Looks like it took uh the word, you know, American recruiters, turned them
know, American recruiters, turned them into American recruiters. That makes
into American recruiters. That makes sense. This was
sense. This was Patrice and Associates. This is
Patrice and Associates. This is Tallahassee recruiters. This is Minesite
Tallahassee recruiters. This is Minesite recruiters turned to Minesite. Yeah,
recruiters turned to Minesite. Yeah, that this all looks pretty good to me.
that this all looks pretty good to me. Um I mean, you know, we only found the
Um I mean, you know, we only found the ones or we only casualized the ones that
ones or we only casualized the ones that actually had email addresses. So, we
actually had email addresses. So, we didn't casualize all of them, but we
didn't casualize all of them, but we casualized most. Pretty solid. Um, now
casualized most. Pretty solid. Um, now I'm just going to set up an MCP so that
I'm just going to set up an MCP so that we could do the email which is part of
we could do the email which is part of the directive that I didn't move over
the directive that I didn't move over previously. Okay. And then I also sent a
previously. Okay. And then I also sent a little email summary of the proposals.
little email summary of the proposals. So, thanks for discussing your lead
So, thanks for discussing your lead generation challenges. Wanted to break
generation challenges. Wanted to break down what you discussed into a clear
down what you discussed into a clear implementation plan. Sending you a full
implementation plan. Sending you a full proposal for the above shortly. Let me
proposal for the above shortly. Let me know if you have any questions or want
know if you have any questions or want to discuss further. Um, got the
to discuss further. Um, got the structure over here. I mean, I just
structure over here. I mean, I just wrote this really quickly so that you
wrote this really quickly so that you guys could see what this looks like as
guys could see what this looks like as an example. I'd probably take out the
an example. I'd probably take out the steps. It looks kind of weird. I also
steps. It looks kind of weird. I also don't like how it's bolded. But [snorts]
don't like how it's bolded. But [snorts] yeah, uh in a nutshell, you know, you
yeah, uh in a nutshell, you know, you can use this thing as your operating
can use this thing as your operating system. You can use this as your entire
system. You can use this as your entire business OS. You don't necessarily need
business OS. You don't necessarily need to even really use like a graphical user
to even really use like a graphical user interface for anything anymore cuz you
interface for anything anymore cuz you can just tell it what you want it to do.
can just tell it what you want it to do. And the context is long enough that you
And the context is long enough that you could, you know, use this as your
could, you know, use this as your proposal generator, use this as your, I
proposal generator, use this as your, I don't know, transcript thing, use this
don't know, transcript thing, use this as your like review tool for sales
as your like review tool for sales calls. You could use this for all of
calls. You could use this for all of your fulfillment obviously by designing
your fulfillment obviously by designing uh extemporaneous automations in an
uh extemporaneous automations in an executions folder. You could use this
executions folder. You could use this for all of your own company SOPs by
for all of your own company SOPs by storing them in directives up here. I
storing them in directives up here. I mean you could use this thing for
mean you could use this thing for basically anything. And I'm sure
basically anything. And I'm sure graphical user interfaces will come up.
graphical user interfaces will come up. This is still very much like DOSS style
This is still very much like DOSS style back in you know like the 70s ' 80s and
back in you know like the 70s ' 80s and '90s. Um at least for what I believe
'90s. Um at least for what I believe will be the future of communicating with
will be the future of communicating with these interfaces. But yeah, pretty
these interfaces. But yeah, pretty powerful already. Okay. So, I'm going to
powerful already. Okay. So, I'm going to give you guys all uh what you need in
give you guys all uh what you need in order to have this self-annealing
order to have this self-annealing agentic workflow generator and operator.
agentic workflow generator and operator. Um, all you really need, as I've shown
Um, all you really need, as I've shown you guys before, is some sort of like
you guys before, is some sort of like initialization file, like an agent.md,
initialization file, like an agent.md, cloud MD, or a Gemini MD. Want to make
cloud MD, or a Gemini MD. Want to make sure you guys have that. And then from
sure you guys have that. And then from here on out, all you need to do is just
here on out, all you need to do is just open up your uh own workspace in the ID
open up your uh own workspace in the ID of your choice, initialize with that,
of your choice, initialize with that, ask it to actually create the project
ask it to actually create the project structure for you, and then do whatever
structure for you, and then do whatever the heck you want. Man, it's a free
the heck you want. Man, it's a free world. And just like that, you guys are
world. And just like that, you guys are now set up. You have your directives
now set up. You have your directives folder for your SOPs. You have your
folder for your SOPs. You have your execution folder for your tools. You
execution folder for your tools. You have your system prompt configured to
have your system prompt configured to enforce that DO framework and then
enforce that DO framework and then enable self-annealing as well. And you
enable self-annealing as well. And you probably even now have a couple of basic
probably even now have a couple of basic workflows. To make a long story short,
workflows. To make a long story short, your environment is ready. And hopefully
your environment is ready. And hopefully this AI employee is now hired and
this AI employee is now hired and sitting at their desk. We've covered a
sitting at their desk. We've covered a ton of ground today and I just want to
ton of ground today and I just want to take a moment to thank you for being
take a moment to thank you for being with me. Before we end, let's recap to
with me. Before we end, let's recap to really instill these concepts in your
really instill these concepts in your brain. So, we started with a few
brain. So, we started with a few examples of realistent workflows I use
examples of realistent workflows I use in my business including lead scraping
in my business including lead scraping and then proposal generating. We then
and then proposal generating. We then discussed the main problem with agents
discussed the main problem with agents up until now which is basically the
up until now which is basically the stochastic or flexible nature of LLMs
stochastic or flexible nature of LLMs and why that means they typically fail
and why that means they typically fail in higherend business applications.
in higherend business applications. After that we introduced the solution
After that we introduced the solution which was the DO framework which
which was the DO framework which separates directives orchestration and
separates directives orchestration and execution to bring a lot more
execution to bring a lot more reliability into actual agentic
reliability into actual agentic workflows. Then we learned about self
workflows. Then we learned about self annealing which is this concept where
annealing which is this concept where you give your agents the ability to
you give your agents the ability to learn from their mistakes and then
learn from their mistakes and then rewrite their own tools to get stronger
rewrite their own tools to get stronger over time. And then finally I showed you
over time. And then finally I showed you guys how to practically set up a
guys how to practically set up a development environment. In this case,
development environment. In this case, it was anti-gravity to host these agents
it was anti-gravity to host these agents for you. So, what you have now is not
for you. So, what you have now is not just a collection of scripts. You have
just a collection of scripts. You have everything you need in order to build a
everything you need in order to build a very high ROI agent business operating
very high ROI agent business operating system. Basically, you have the tools to
system. Basically, you have the tools to take any repetitive high-v value task in
take any repetitive high-v value task in a digital business, whether it's lead
a digital business, whether it's lead genen or proposal writing, customer
genen or proposal writing, customer support, data analysis, literally
support, data analysis, literally whatever the heck you want, and then
whatever the heck you want, and then turn it into an autonomous
turn it into an autonomous self-improving workflow. So, yeah, this
self-improving workflow. So, yeah, this is the future of work. It is not coming.
is the future of work. It is not coming. It is already here. The only thing left
It is already here. The only thing left to do is actually build it and then
to do is actually build it and then distribute it. And if we're smart about
distribute it. And if we're smart about how we do so, you and I can actually
how we do so, you and I can actually meaningfully influence the economy,
meaningfully influence the economy, which was my whole idea behind making
which was my whole idea behind making this free course. If you guys like this
this free course. If you guys like this sort of thing and you want to build a
sort of thing and you want to build a workflows professionally and maybe even
workflows professionally and maybe even get paid for it, do check out Maker
get paid for it, do check out Maker School. It's my 90-day accountability
School. It's my 90-day accountability roadmap to take you from zero to your
roadmap to take you from zero to your very first paying customer for an AI
very first paying customer for an AI related service. I also guarantee
related service. I also guarantee results. So, if you don't land your
results. So, if you don't land your first customer in that time, you do get
first customer in that time, you do get the money you spent on my program back.
the money you spent on my program back. Otherwise, have a lovely rest of the day
Otherwise, have a lovely rest of the day and I'm looking forward to seeing what
and I'm looking forward to seeing what you guys build. Cheers.
Click on any text or timestamp to jump to that moment in the video
Share:
Most transcripts ready in under 5 seconds
One-Click Copy125+ LanguagesSearch ContentJump to Timestamps
Paste YouTube URL
Enter any YouTube video link to get the full transcript
Transcript Extraction Form
Most transcripts ready in under 5 seconds
Get Our Chrome Extension
Get transcripts instantly without leaving YouTube. Install our Chrome extension for one-click access to any video's transcript directly on the watch page.
