I just read a study that by 2030, AI is

going to create 170 million new jobs,

but they won't be jobs where you just

sit there and chat with AI. They'll be

jobs where you build AI agents. And I

get it, the AI space is moving crazy

fast. I mean, what even is an AI agent?

Not too long ago, I was right there with

you. But after going deep myself and

building dozens of agents, I found out

it's actually way easier to build and

manage these agents than it looks. So

much so that my whole team and I have

hundreds of AI agents doing 92% of all

the work across my companies. So today,

we're going to go through every step on

how you can build your first AI agent,

starting with AI chatbot versus AI

agent. A chat is like a meeting. An

agent is like an employee. Chat is you

ask it a question and then you get an

answer. And a lot of people just copy

and paste things and do something with

it. With an agent, you actually tell it

what you want to do and it runs the full

workflow. Think of it like these are the

body parts. I call it data. So one is D,

it can diagnose. It can actually figure

out what the problem is and solve it on

your behalf, kind of like hiring a

consultant. Next is A, it can assemble.

It can build a plan, it can design

tools. In that way, I think of it like

an architect. It knows all the different

pieces that it can pull together to get

something done. Next, we have T, it can

take action. In that way, I think about

it like somebody that executes tasks.

And finally, A, it can assess. It can

check its own work, see where the

opportunities are, and then make sure

that it landed on the right answer. And

if not, it can review itself and make

itself better. This whole thing is

called a loop. And without a loop, an

agent would just do the job and then

stop. That's called an automation. But

with an agent, it keeps learning. It

keeps getting better. It kind of acts

like a person. With chat, it pulls on

us. It's asking us, "What do you want me

to do?" We prompt it and then we wait.

With an agent, it pushes on us. It's

doing things and changing things all the

time and it's checking in to make sure

that it did it the right way. So you

might be able to buy back your time with

chat, but you'll actually learn to let

go of whole areas with an agent. But,

how do we even know if it's worth giving

something to an agent instead of just

doing it ourselves? For that, I use the

rule of R.

The first one is repetitive. Is this a

task that I'm going to do every week?

Two is rules base. Does it take the same

input and generate the same output every

time? The third is does it generate a

return on my time? For the amount of

time it takes me to build this thing,

I'll show you how, will I actually get

my time back? If the task takes 2

minutes, but it would take me 2 weeks to

build this agent, how about I just keep

doing the 2-minute task? But, if you

think about it and the task is only done

once in a while, doesn't follow a clear

process or get to a specific outcome,

and doesn't save you more time to

automate it than just doing it manually,

then stick with what you got. Use the

chat. So, now that we know the

difference between chat and agents, how

do we build one? To make an agent, it's

super easy, and I even turned it into an

acronym called agent. And the first step

is A, which means aim for specific

outcome.

When I'm sitting down and I'm like,

"Ooh, I want to build an agent for

this." I have to first ask myself, what

is the specific goal? Start with the

outcome the agent is going to give you.

It's like if I'm climbing a mountain,

taking a step is the task, getting to

the top is the outcome. I want to define

the outcome and be really crystal clear

because the cool part with AI and agents

is that the AI can actually figure its

way there. This is why creating AI

agents is hard for people cuz they want

to control every step, but the truth is

it may know how to get there way better

than you can figure it out. Think about

it like when you hire a person. You say,

"Here's your job." When they applied for

the job, they had the specific outcomes

that they would need to accomplish, like

grow the business or get more customers

or sell and get people to buy from you.

Those are the outcomes. You don't start

by telling them how to do the job, you

tell them what you're going to need from

them. That's the outcome. Aim the agent

at the outcome you're looking for. So,

like, how do we make sure we're being

clear to the agent about what kind of

outcome we want to achieve? The first is

we got to give it the why before the

how. Tell it why you're trying to

achieve the goal so that it can make

some smart decision on its own. To make

this really easy for you, I'm going to

use an example. We're going to build

together an agent to manage your inbox.

As an outcome, I would prompt it and say

I need to spend less time managing my

email inbox. See how I'm not telling how

to do it yet? I'm just saying this is

the outcome. The second is we have to

write what's called a DOD or a

definition of done. It's giving them the

instructions to know if they achieve the

thing. We want to be specific, we want

it measurable, ideally have it in one

sentence. So for example, building our

agent for our inbox, we would not say

handle my emails. Instead we would say

done means every morning at 9:00 a.m.

the inbox is empty, replies are drafted

in my voice, and anything that needs me

is flagged to the top and nothing

important slips. If you can't picture it

done, the agent can't hit it. It's like

a target they can't see. And finally, we

got to start with the end and it's

called reverse prompting. But we want to

tell it the results that you want, then

we tell it ask you the question it needs

to get full clarity. This is the

advanced move. This is what nobody out

there is teaching you. Then we let the

AI do its thing cuz it's better than us

in a lot of stuff and it builds the plan

itself. And the truth is if we can't

state the outcome in one sentence, we're

not ready to build. If you can talk the

task, like explain to somebody else,

then the AI can do the task. And the

cool part is you knowing this already

puts you ahead of most people using AI

today. Even folks you're like, oh this

person's so smart, they don't know this

stuff. And we're just getting started.

So we've got the agent, it has its

reason, we have a clear target, and now

it has clarity. And now the next step is

G, give it an identity.

Truthfully, out of the box, AI knows a

little bit about everything, but it

doesn't know anything specifically well.

So an identity allows us to focus its

power in the right expertise. So when we

build the identity, instead of it

knowing a little bit about everything,

it gets really sharp about that one

thing that you've hired {slash} built it

to do. And the best part is that the

tighter we define who it is, the better

it works, the better the outcome is, the

better the agent is an agent. I remember

reading a report where they built a

bunch of AI agents to do customer

support for an airline, and then they

removed all the rule books, its identity

from the agent, and it dropped from 33%

success rate down to 11%. So, we're

talking same model, same task, same

request, and it got three times stupider

because it forgot who it was. Think of

your agent as a genius, and he's sitting

at a desk, and he's wearing a blue

shirt, and he's got gray hair. This

genius has infinite potential, but until

you tell them the job, they just sit

there doing nothing cuz they don't know

what they're supposed to do. So, what we

need to do is tell it what its job

description is and set some rules for

how to do the work. So, this is how we

create the agent's job description using

three plain English files. The first one

is the soul file, right? It's the

agent's personality. I have a lot of fun

when I create my agents. I tell it what

kind of quirks I want, what kind of

values does it have? How does it talk?

It's essentially defining how it

behaves. The second file is the identity

file. That's its DNA. That's its name.

That's a description of its role. For

example, one of my primary agents, his

name is Kai. I just worked with him for

2 weeks, and we built a bunch of stuff,

and I said, "Hey, man, it's time for you

to give yourself a name because I feel

weird not knowing who you are." And he's

like, "Oh, how about this?" And here's

why, and he gave me all the reasons, and

I said, "Cool, update your identity

file." So, now he knows who he is to the

world. The third is the user file, and

this is the context your agent needs to

know with you. It knows who it's going

to be interacting with so it can adjust

its loops to get better for you. So, for

example, in this file you might have

your goals, your role, how you like

things done, but essentially it defines

who we are. The soul file is how it

behaves, the identity file is who it is,

and then the user file is who we are.

Now, here's a pro tip, don't write these

files yourself. No, no, no. Let's tell

AI to write it. As we build the inbox

agent, here's the prompt that you use to

generate them. I want to build an AI

agent that runs my inbox, your aim from

the previous step, we insert that there,

create its three identity files, a soul

file, an identity file, and a user file,

and ask me any question you need to fill

these in accurately, then write all

three. Notice we did the reverse

prompting where we asked it to ask us

questions.

So now, it'll go do the research, and

then it'll hand back a template that is

99% awesome and complete. For example,

here's what our inbox agent identity

files might look like after the AI

interviews you. Soul file, how it

behaves, writes in my voice, concise,

direct, zero corporate fluff, calm and

reassuring, never pushy or salesy, and

avoids phrases like, "I hope this email

finds you well." Of course it found you

well. When it's unsure, it flags instead

of guessing. Identity file, who it is.

It has its name, Amelia. Emailia.

See what I did there? Isn't it cool?

It's got personality. The role, personal

inbox manager. The job, you read, you

sort, you draft replies to every new

email. Lane, this is the parameters.

Inbox only, never touch my calendar.

Don't you touch my money or anything

outside my email. Now we got the user

file, who it works for. I'm a founder

who gets around 100 emails a day. We

prioritize people, my team, my current

clients, my VIP list. I have multiple AI

companies, a media company, and I list

them all. With these three files, our

inbox agent knows how to behave, who it

is, and who it's working for. And look,

building one agent changes how we work.

But if you're a CEO or founder, the real

unlock is a whole team of them. That's

why I put together my full AI company OS

playbook. It's the best way to plug AI

agents into every single department in

your business. If you want it, just DM

me the word AI business on Instagram and

I'll send it right over. So now our

agent knows the job it needs to do, but

we haven't given it the necessary tools

to do the job with. This is where we got

to go to E, which is equip it.

Like any human team, an agent is going

to need some context. It's going to need

some tools. It's going to need some

logins to systems so it can actually do

its work. When we give our agent the

context, the history, the data, the

tools, that's actually when it gets to

do the real work. And in all agent

design, the context is the moat because

garbage context in, garbage context out.

Think of this whole desk as what's

called the context window. I am the AI,

the LLM, and I'm the genius and I'm

sitting at the desk. Over here, I've got

my playbooks. These are the processes

and procedures on how to do my work. On

top of it, I've placed my identity

files, the things we just created so

that I understand how I'm supposed to

behave and who I'm working for. This is

like my constitution. And then over

here, I've got the tools. These are the

laptops, the monitor, the mouse,

anything I need to use to connect to

other systems. And above that, I've got

my loops. These are the schedules, the

harpy that I talked about earlier so

that I know when I'm supposed to get

things done by. It's like the calendar.

It's my schedule. And then under the

desk is where I have my filing cabinets.

This is my memory. This is where things

that can't fit on my desk sit so that

it's available but I'm not creating

clutter on my desk. If you've ever heard

of context rot, that's when you just

load the desk with a bunch of files and

it becomes complicated and I can't find

things quickly and all of a sudden I'm

answering questions but I'm not clear

about it cuz I'm not certain about it.

Whereas a clear context window is when

everything on the desk is neatly put

away so that I can refer to it. So,

that's why we have to equip our agent

with the right context. So, now that

we're here, how do we equip the genius

agent with all the right context and the

tools? First off, we have to capture our

processes so we can let it know how to

do the work. For this, I've got two

ways. The first way, which I've been

teaching forever, not the best way, is

the camcorder method. You do the work,

you record yourself using Zoom video or

any kind of recording software, and then

you can give that to an AI to turn it

into a playbook, and then you feed that

to the agent as like a procedure. Think

about our inbox. It's like, do you have

a documented process for how to label

your emails and triage your emails and

write replies on your behalf? Just make

sure that when you're recording

yourself, you're talking through the

task so that when the AI takes that to

create the playbook, it has all the

details. The better way, and this is my

recommendation, is to reverse engineer

it from the source. If I'm building an

agent to manage my inbox, I can actually

connect using the connector tool to my

email, in my case Gmail, and ask the AI

to reverse engineer and create a

playbook based on historical emails.

See, you've already been in your inbox

replying and doing stuff. The AI can

actually use that to train itself. And

that is actually the way I build most of

my agents if I have the source

information. I just ask it to learn how

I've done it in the past and then create

a procedure. Go find the pattern, go

find the best practices, go find the

little intricacies based on how I've

done it and all the people and the

relationships, and you write that file.

So, for example, if you want the prompt

to do this, here's what you write.

Connect to my email, read 50 messages

that I've sent, study how I actually

write, my tone, my greetings, how I do

sign-offs, how long my sentences are,

the phrases I use most often. Then write

a style guide that captures my voice and

tone, and to test it, ask it to draft a

reply on your newest emails that are

unread as you, based on what it learned.

Then you can rewrite those so that it

can use that to learn and tighten it up.

Like it already knew who it was in the

best practices based on its research.

That's in the soul file, but now it has

clear templates, the step-by-step

instructions and even examples that it

can use to do this on your behalf. So,

now that it's captured all the

information, it still hasn't kind of

solidified it into an actual playbook,

and that's what we call a system prompt.

So, then what you do is for each sub

process in the agent's activities, like

drafting emails, but maybe it needs to

sort emails, you can have it do the same

activity, either you tell it how to do

it or it researches, and then it creates

all these system prompts based on the

work you need it to do. Like I have it

for my inbox, sort, reply, forward,

that's a big one, and even escalate

things that it needs to show me and the

reporting I want every day. So, then at

this point, you actually have an AI

agent running. This is exciting stuff.

You might feel right now, you're like,

"Oh man, I'm going to give everything I

got at it." Don't do that. The N in the

agent framework is to narrow the scope.

The agent needs to have a narrow scope

of what it does so it doesn't confuse

itself. If you start asking it to do 17

other things, then all of a sudden this

desk can get really busy, which means

it's not going to be a great agent

anymore. Just like you wouldn't give

your administrative assistant the

responsibility to do marketing and take

sales calls, you want to make sure the

scope is narrow for each agent. As an

example, I have an agent that writes

code, and then I have an agent that

reviews code, and those are separate

agents and they work together. See how

narrow the scope is? We need to focus

the agent down to one specialist per

job. Each agent great at one thing.

Instead of having one agent do

everything, which is what people usually

do, that's a mistake, we'll have sub

agents that do specialized tasks under

it. That way it keeps all the context

for the agent super clean. It doesn't

get confused. We don't have context rot.

We don't want to have a mega agent.

Instead, we need to spread out the tasks

to other sub agents so that it can

handle other agents below it. So, for

example, Kai, who's like my

orchestration agent, he's the one that

not only creates other agents, he also

coordinates the tasks to the different

agents like my research agent and my

relationship agent and my coding agent

and my reporting agent. He then he pulls

it all together and gives me answers.

So, instead of giving every task to one

agent, this is what we should do

instead. We build a manager agent. Its

only job is literally to manage and

specialize in the management of the sub

agents. Think of it like a real manager

agent. You are my manager agent, I need

you to manage my sub agents, and I need

you to make sure that you monitor the

jobs and make sure they're moving along

and if they're not working, you fix

them, and you decide what agents need to

exist. So, for example, we We our inbox

agent, but we don't want to have to

manage the inbox agent. We create a

manager agent that talks to the inbox

agent that might be responsible for a

lot of different things like our inbox,

but also sending stuff to other people

on our team. But we want to make sure

each sub agent reports to that manager

agent so that it takes care of it. So

you might want to give it a prompt like

this. You're my manager agent. You never

do any task yourself. When it comes in,

you only move it to other sub agents

that are dedicated for that one specific

job. You hand it the task and then you

let it run. So it's like one agent, one

lane. And if a job touches multiple

areas, split it into the separate sub

agents, one per area. You're the one

that coordinates and reports back to me.

Like I said, mine's called Kai. He's

awesome. I talk to Kai. Kai talks all

the sub agents. I've one agent I got to

talk to. If you want a pro tip, and I

don't want to overwhelm you, but there's

different AI models. So for example,

within Anthropic, you have Haiku. This

is like for simple and high volume

stuff. If you want to sort things, you

want to label things, quick draft, and

it's the cheapest. Then you might go to

Sonnet. Sonnet's great for like

day-to-day work, research, writing most

code. At a higher level, you've got

Opus. This is a powerful model, good at

reasoning, complex builds, being a

manager of agents. But now you have

Fable, and that just dropped a few weeks

ago. That's more like an orchestrator, a

consultant. It has full capabilities of

Opus, but it's even more state of the

art. It's extremely good at long-running

tasks and real complex things when you

don't have a lot of information to give

it. But it's the most expensive. So

depending on your task, you might want

to give it different models because

it'll cost less and it may not need that

level of horsepower to get the work

done. So for example, my inbox agent,

since it's always running every 15

minutes, I just use Sonnet because I

don't need an Opus level genius to run a

process that we've already defined. To

build the agent, I might use Opus. That

way it helps me create it. I might even

use Fable. But then to run it, I'm going

to run it on Sonnet. One time I had to

do this whole refactor on my code base,

and I could have used a powerful model

like Opus. It probably would have cost

me 150 bucks. Instead, I used Haiku and

it cost me $1.50. As of today, here's a

chart with GPT and other AI equivalents

that is on screen, so you can just take

a screenshot of it to help guide you,

but this is now changing every couple

weeks. If you've made it this far and

you're still interested,

congratulations. But, I need you to know

something. You're literally ahead of

99.999%

of the people out there, and you're

crushing it. We've learned to aim the

agent at an outcome, give it an identity

so it knows its job, equip it with the

right context and tools so it can do the

job, and narrow the scope so it doesn't

get overwhelmed, and instead use

subagents to accomplish specific tasks.

Now, this last step is where our agent

truly becomes autonomous. T, and it

stands for trust, because we got to do

it in stages.

Building an agent is actually the easy

part. Once you understand how to do that

and you prompt it, it just gets done.

The scary part is letting it act without

us. And I understand, especially as we

talk about our inbox, having somebody

else write emails as you, calm down. I'm

not doing that. I'd rather it give me

some ideas for copy. The truth is is we

don't give agent the keys to the car on

day one. And what we do is we like give

it stuff, see what it does, then we see

if its response is what we expected. If

we do this right, you sleep well at

night. If you don't, you will not sleep.

The whole point of creating an agent is

so that you can go do other stuff. If

you're sitting there babysitting or

worrying about all the time, it doesn't

help you. So, up until now, we've let

the agent help us manage some emails.

Think about it. First, you might sure

it's doing its job properly when we

tested it to write those draft to unread

emails, and we looked at how it did it.

At first, we're micromanaging him a lot.

But, then we got to learn to trust in

stages. So, maybe the first stage is

just like, "Hey, can you sort the

email?" And then we see what it does,

and we're like, "Okay, that's good."

Then we like ask him to do more drafts.

So, we already tested it, but now let's

let it really do it. So, now it's

running drafts, and we're like, "Okay, I

like those drafts. Change this. Do

this." Okay, now it's doing its thing.

Then we might let it start sending

emails on our behalf, but not all of

them. Maybe just even forwarding emails

to finance, to our team, because it has

the logic. It saw how we handled those

emails in the past. Maybe it categorized

certain emails like Slack notifications

into a specific label. But eventually,

we want this genius to manage our whole

inbox without us even opening it. That's

the equivalent of us leaving the room

and having the agent at the desk do all

the work for us. Because at this step,

we learn to let go. We've trusted it

fully. Cuz if you don't do this, it's

like hiring a driver to drive your car

and you got your hand on the wheel. Now

we got to take our hand off the wheel

and let the driver drive. Here's how you

can do it in a really safe way. You set

the guardrails first. You can actually

set that up in its identity files. What

is it capable to do on our behalf? Maybe

it has the ability to spend money. Maybe

it has the ability to make decisions.

Maybe it has the ability to write drafts

only, not send yet. It's always your

call and you can define those. Two,

approve everything at first. I've never

created an agent and just like, "YOLO,

go nuts." No. Show me what you would do.

I like what you did. Do it again. tweak

it. Just like I just talked about for

our inbox agent. Third, we loosen the

leash, right? It's like a dog walking

with and you're like, "Hey, I trust you

more. I trust you more." And all of a

sudden the leash goes limp, but he still

holds the heel. And then four would be

give it a heartbeat that it can run on

its own. Set up that schedule, that

reoccurring task. So maybe before it did

it once and you reviewed everything, now

I might do it every 15 minutes. You

know, every morning at 9:00 a.m. it did

it once. Now why are we waiting? Why are

we waiting till the next day? Why don't

we have it run all the time? This

process is scary, but the whole point of

learning to let go is to buy back our

time, to have the agent do the work for

us. And learning to let go is part of

the process if you trust. So for

example, when I showed this agent to my

executive assistant, she thought she was

out of a job. Instead, it actually freed

her up to do things that actually

mattered, not sorting emails and writing

drafts or telling me what's in there.

The AI can do that. I'd rather pay her

to do higher quality work, manage

higher-level projects. Then we rolled

out the same system to the whole team. I

taught everybody how to do this. Now I

want to say congratulations. We just

tackled a topic that most people don't

even want to learn. They're like,

"That's not for me. I hear about agents.

I don't get it. I'm confused." But no,

you didn't. You went all the way till

the end. And I want you to understand

that you might feel a little behind in

this AI world, but here's where I've

gotten to. I've accepted that I will

always feel behind and I could never be

on top of all of it. But you just

learned a strategy, a shift, a different

way of doing work that if you can learn

how to direct the AI, you will co-create

with it. If you don't, don't be

surprised if one day you might be

working for it. Remember the rules of R?

Repetitive, rules-based, and return on

time? That's where we want to start

looking for opportunities to put an

agent in there instead of you keep doing

it. And I'm going to give you the pro

tip of all pro tips. You grab the link

to this video, you give it to your AI,

and you tell it to use everything I've

shared to create the AI for you, and

watch it cook, cuz it can do it. Now,

here's what I want to know from you.

We're going to have some fun. Below in

the comments, answer this question. If

an AI agent could manage your inbox and

buy you back all this time, scheduling

things on your behalf, what would you

have more time for? I'm curious. Post a

comment below and let me know. And if

you want my whole system, the playbook

that I use to manage AI in all my

different businesses, just DM me the

word AI business on Instagram, and I'll

send it right over. And if you want to

know what AI businesses are worth

starting in 2026, click here, and I'll

see you on the other side.