AGENTIC WORKFLOWS: Build & Sell AI Automations (2026)

0:00Hey, welcome to the definitive guide on

0:01agentic workflows for business. Now,

0:03agentic workflows have the potential to

0:05bring about what I think is one of the

0:06largest wealth transfers in human

0:08history. But very few people are

0:09currently talking about how to

0:10practically use them to improve their

0:12financial means. That's what this video

0:14is going to show you how to do. Here's

0:15what you're going to learn. What an

0:16agentic workflow really is. How agentic

0:19workflows function via loops. A few

0:21common problems with agentic workflows

0:22and how to fix them. How to actually

0:24build these things. So, idees, setting

0:26up your workspace, creating your first

0:28flow, the DO framework, directive

0:30orchestration and execution, claude

0:32skills, MCP and other frameworks, what

0:35each one does, when to use which and how

0:36they all fit together, how to test and

0:38validate agentic workflows, the best

0:40system prompts for agentic workflows,

0:42which I will give you, how to make your

0:44workflows self annealing, aka heal

0:46themselves when they air out, how to

0:47move out of the IDE and into the cloud.

0:49I'll teach you how to create web hooks,

0:50schedule triggers, and more. How to run

0:52multiple agents simultaneously. I'll

0:54show you a sub aents and advanced

0:56workflow parallelization. And finally,

0:58how to troubleshoot agentic workflows

1:00when things break. If you don't know who

1:01I am, I build two AI based service

1:03agencies to $160,000 a month in combined

1:06revenue. I've also consulted for a

1:07couple of billion-dollar businesses with

1:09AI. And I tell you this cuz I want to

1:10make it clear. Well, you guys are of

1:12course going to learn everything from

1:13the fundamentals all the way up to the

1:14advanced concepts today. This course has

1:16a business focus. My goal is to help

1:18prepare as many people as possible for

1:19what I consider to be the next stage of

1:21the economy. So what you will learn

1:22today is working right now. It is

1:24generating revenue right now and you can

1:26use it to improve your own and other

1:28people's businesses right now. Please

1:29bookmark this and use the chapter

1:31feature to come back to it or whenever

1:32you need anytime. And I hope you guys

1:34are excited as I am to get into Agentic

1:36Workflows. Let's get started. This is a

1:38practical course. The whole point of it

1:40is to build and then use Agentic

1:43Workflows in real business environments.

1:46And that's because building is the most

1:47effective way to learn anything. When

1:49you build with your hands and get them

1:51dirty, you're forced to deal with

1:53concepts in a way that you guys never

1:54would have if you just sat back and

1:56passively listened. That said, before we

1:59get into the building, and there will be

2:01a lot of building and a lot of demos in

2:02this course, there are some foundational

2:04things about agents and workflows that

2:06I'd highly recommend that you understand

2:09because if you don't understand them,

2:10you're going to commit many hours to

2:11this course and you'll only really be

2:13able to digest or extract a few

2:15percentage points of it. So what I want

2:17to do is I want to maximize the ability

2:19and efficiency of your time by helping

2:21you cover those concepts now. And by

2:23doing that, you'll be able to absorb the

2:25rest of the course a lot faster and a

2:27lot better. So what do I mean by

2:29concepts? AI is currently in an overhang

2:32state. Current AI capabilities are very

2:35far beyond what most people believe,

2:37expect, or know how to use. If you guys

2:40graft this, what we have down here is

2:43sort of like the general public's

2:45perception of AI, okay? And their

2:47ability to use it. And what we have

2:50above it is sort of like the reality,

2:54okay? You guys are going to see a lot of

2:56very crappily drawn lines in this

2:58course, so you might as well get used to

2:59them now. So this gap between the

3:02reality of the situation and then what

3:04people believe AI is capable of is

3:07called the overhang.

3:10The reason why this overhang exists and

3:12the reason why people are only squeezing

3:13out a very small percentage of the

3:15actual value of AI, large language

3:17models, agentic workflows and so on and

3:19so forth [snorts] is because right now

3:21most people are using them as glorified

3:23copy and paste tools. They are basically

3:25trying to drink through the Pacific or

3:27Atlantic Ocean with a tiny straw. You

3:30know, they ask these galaxy brain

3:32intelligences. Pretty dumb questions to

3:34begin with to be honest. They answer and

3:36then all they do is they copy it from

3:38one tab into another, which is obviously

3:40a very low bandwidth, really

3:42bottlenecked way of working. They are

3:44not integrating AI into their business

3:46like I'm about to show you how to do in

3:48this course. Instead, they're just

3:50dealing with it like a like an external

3:52sort of third party thing.

3:54Now, obviously, people are figuring out

3:56that AI is a lot more powerful than most

3:58people give it credit to, and courses

4:00like mine are helping them do so. But as

4:02they figure it out, the arbitrage window

4:04will close. And in case you guys didn't

4:06know, arbitrage is your ability to

4:08essentially produce some sort of

4:10beneficial outcome, revenue or profit,

4:12based off of a disparity in knowledge.

4:15And so, if you know, you know, this and

4:18the rest of the market knows this,

4:21obviously there's kind of a gap there,

4:22right? and the market is willing to pay

4:24you to be somebody that solves that

4:26little tiny gap. Well, that window is

4:28closing because people are learning

4:30about how this technology works. But

4:32right now, it's wide open and you can

4:34make a ton of money with it. So, just as

4:35a demonstration to show you how powerful

4:37these models are, I'm going to have one

4:39in particular called Claude Opus 4.5 do

4:42a pretty straightforward task for me.

4:44This task is to compile a list of five

4:46local meal preparation companies that

4:47deliver to around my area and then find

4:49their email addresses. I'm then going to

4:51send each of them emails with

4:52specifications from this email. I want

4:54uh you know 3500 calories a day, 200

4:56grams of protein a day. I'm doing some

4:58big bulk. Do this entirely autonomously

5:00requiring no input from me. If you

5:01cannot find the emails of at least five,

5:03then keep on searching until you do.

5:05Most people don't realize that models

5:06are entirely capable of doing this sort

5:08of thing for you and essentially acting

5:09as you know an extension of yourself. So

5:11it's starting off by searching for meal

5:13prep delivery companies downtown

5:14Vancouver BC 2025. If I were doing this

5:16on my own, this is probably something

5:18that I would do as well, right? like

5:19very straightforward and logical. You

5:21don't need to know how the IDE that I'm

5:23using uh works. You don't need to

5:25understand the interface or everything.

5:26I'm going to cover all this later on in

5:28the course. And as you can see, it's

5:30found me a bunch of meal preparation

5:32services. There's Fresh Prep, Two Guys

5:34with Knives, Crave Healthy, Fed, Fresh

5:37in Your Fridge, K-Bop, and then WellFed.

5:39Now, it's finding email addresses of

5:41each of these. So, as you can see, it's

5:42actually simultaneously running a bunch

5:44of searches on their websites to look

5:46for email addresses or contact methods.

5:48A few seconds later, it looks like it

5:50could only find one email out of the

5:52four or five searches that it ran. So,

5:53what is it doing instead? It's now

5:55broadening its search. It's going on

5:56contact pages. It's looking for

5:58alternative solutions. Okay, it's now

6:00accumulated the email addresses and like

6:01a temporary database. And it's just

6:03going through and sending emails. It

6:05does so through uh what's called an MCP,

6:07model contact protocol server that I've

6:08set up. I'll show that to you later. And

6:10boom. Now, it is done. So, we've sent

6:12five emails. Down here, you can see it

6:14said, "I asked each company about custom

6:16meal plans, pricing for higher volume

6:18orders, and their delivery schedule to

6:19downtown Vancouver." We also included

6:21the requirements. I went through and I

6:23actually found the email that it sent.

6:24It was something like this. Hey, company

6:27team, I'm looking for a meal prep

6:29service that delivers to downtown

6:30Vancouver and that contains the

6:32following requirements. Daily calories

6:34approximately 3500. Daily protein

6:36approximately this much. Focus on whole

6:38foods and healthy ingredients.

6:39Interested in learning more? Do you mind

6:41letting me know? you know, if you guys

6:42offer custom meal plans, um, what your

6:45pricing looks like and how your delivery

6:47schedule works. Looking forward to

6:48hearing from you. Thank you very much.

6:50So, I mean, like, this is something I

6:51realistically probably would have sent

6:53myself. Um, is it in my exact tone of

6:55voice, honestly? Like, it's really

6:56close. This is more or less everything

6:58that I would send. There's no AI isms.

7:00People on the other end of the line

7:01aren't going to know that I'm using AI

7:02to do this sort of thing. And it turned

7:03a process that realistically would have

7:05previously taken me maybe like 20

7:06minutes into something that took me

7:08literally less than 15 seconds. I mean,

7:10I wrote the thing, I pressed enter, and

7:12then I went. And what you'll see is with

7:14the use of other bandwidth improving

7:16tools like voice transcription and stuff

7:17like this, you can actually have agentic

7:20workflows become more or less your

7:22interface for the internet. And I should

7:24note that I didn't even use a defined

7:25agentic workflow for this. I literally

7:26just asked an agent to do something and

7:28it was super unstructured and it still

7:29did a great job. Imagine when we wrap

7:31this in the framework. I also want to

7:33cover this idea of a river of value. The

7:35way I see the global economy is as a

7:38giant river. Okay. Now, capital flows to

7:42whoever provides value. And essentially

7:44what occurs is for many centuries that

7:46value has come from human labor,

7:48primarily physical to start, although

7:50eventually cognitive. And then the more

7:53value that people could produce, the

7:55more downstream little tributaries of

7:57this river we found. And so this might

7:59be some person that's producing

8:01tremendous value, these might be other

8:03people and so on and so forth. The whole

8:05idea of capital is that as solutions

8:08arrive in the economy that are more and

8:10more effective, [gasps] they produce

8:12larger diversions of this stream. Okay?

8:16And so let's say this person Z is using

8:19agentic workflows. The idea is over the

8:21course of the next few years, he or she

8:23is going to consume more and more and

8:25more and more and more of that river

8:27until essentially he's getting all of

8:30it. Those who position themselves as

8:32people like Z in this case will capture

8:35massive flows from the future economy

8:37because agentic workflows aren't

8:39optional. There's something that are

8:40coming and being deployed right now. The

8:43last thing I want to talk about is

8:44automation in the terms of a Gentic

8:47workflow. Now, a lot of people that

8:49watch my channel and are probably here

8:51are familiar with the idea of

8:52automation. They're also familiar with

8:54the idea of roles and they've heard a

8:57lot of things about how AI agents are

8:59coming and their whole fleets of teams

9:01that are being replaced and so on and so

9:03forth. And this is kind of inaccurate.

9:06Rather than thinking about agentic

9:07workflows, which is what we're going to

9:08cover in this course, as being able to

9:10automate 100% of one role, I want you to

9:14think about it a little differently. I

9:15want you to think about agentic

9:16workflows as being capable of automating

9:1890% of 10,000 roles. So as opposed to

9:22automating 100% okay of one, we're

9:27automating say 90% of 10,000 people in

9:31the organization. Now if you automate

9:33100% of one role, that's actually pretty

9:35valuable. Don't get me wrong. If I could

9:36automate a software developer completely

9:38end to end, if I could automate a

9:40marketer end to end, obviously that

9:41produces some value in my organization.

9:43But agentic workflows, like a lot of

9:45technology, have gaps. And so, um, the

9:48main issue is human beings tend to

9:49always have a little bit more context

9:51than these things do, at least right

9:53now. And so, even the ability to

9:55automate 90% of 10,000, despite the fact

9:57that it's not 100, is still tremendously

9:59valuable. If you just do the math,

10:01automating 100% of one person's role is

10:03equivalent to basically providing one

10:05unit of economic value. Whereas, if you

10:07automate 90% of 10,000 people's, you're

10:09providing 9,000 units of economic value.

10:12As long as you structure your companies

10:13in a way to accommodate these things,

10:15these things are very powerful. Now, I

10:17call this horizontal leverage and it's

10:19very, very strong. Another way I want

10:21you to think about this is like the

10:23industrial revolution. Back in the good

10:25old days, well, I don't know if they

10:27were really good, but certainly back in

10:28the day, you had people like

10:30seamstresses who would, you know, knit

10:32various garments and stitch various

10:34things together. And maybe one of these

10:36seamstresses could produce, you know, 10

10:38pairs of a specific type of clothing per

10:41day. Well, after the industrial

10:43revolution, obviously we didn't do a lot

10:44of this stuff by hand anymore. We had

10:46machines that did this stuff instead. So

10:48maybe a loom. Before a single seamstress

10:51could produce maybe 10 garments a day.

10:53After one of these machines could maybe

10:55prepare 10,000 garments in a day. That

10:58said, it the machine didn't fully

11:00replace that seamstress because that

11:02seamstress just transitioned. Instead of

11:04being somebody that worked with their

11:05hands on building the garment directly,

11:08they instead became somebody that was

11:10supervising whole fleets of machines

11:11that did it. Now imagine if in this

11:14analogy, not only can we build and use a

11:16loom, we are capable of rebuilding that

11:18loom in any configuration in seconds. We

11:21don't have to, you know, smelt the metal

11:23and then hammer it and then construct it

11:26in a way and screw gears and all that

11:28stuff in order to build a machine. We

11:30could literally just use natural

11:32language. Obviously, that would be a lot

11:34more powerful, right? Well, that really

11:35is the idea of an agentic workflow. It

11:38is something that provides incredible

11:39horizontal leverage and we can

11:41reconfigure it in seconds to do more or

11:43less whatever we want. And it's not an

11:45exaggeration to tell you that this is a

11:47phase change essentially in a company's

11:50ability to automate things. So if you

11:53guys are familiar with automation

11:54platforms, in this case this is N8N,

11:57you'll know that most of the time the

11:59way that we are currently building

12:00automated systems is through drag and

12:03drop nodes or modules. And so on the

12:05left hand side here, I have a simple

12:07system set up. I'm not going to go

12:08through everything because it's

12:09pointless. The point is not to learn a

12:11specific automation platform. The point

12:12is to learn how to automate platforms in

12:14general, but I have a specific

12:15automation here that just responds to

12:17some emails coming in for a cold email

12:19campaign. And as you see here, we have

12:21these nodes and they do various things.

12:23Some of them do HTTP requests. Some of

12:24them do some data processing and and

12:26formatting. Some of them call a Google

12:28sheet. We have some AI functionality and

12:30so on and so forth. They're all

12:31connected with these lines, which is

12:33basically the the flow of logic through

12:35a system. And this is hunky dory. It

12:37works really well. Well, the new version

12:40of that workflow on the left, which

12:42obviously requires a lot of time,

12:45energy, and understanding in order to be

12:46able to to parse and then change is what

12:49we have on the right. Instead of dealing

12:51with nodes and specific software

12:53platforms, we use the universal

12:56translation, which is natural language,

12:58and then just write it out in bullet

13:00points. So on the right hand side I have

13:02the exact same workflow except I have it

13:04set for agentic uh systems and all it is

13:08is a list of bullet points. Hey when

13:10somebody replies to one of your cold

13:11outreach campaigns instantly should send

13:12a web hook. The system should look up

13:14the campaign in a Google sheet to find

13:16talking points and example replies. It

13:18should then research the person who

13:19replied. It should then generate a short

13:21friendly reply. If they said something

13:23negative like unsubscribe or remove me,

13:24we should skip them. If there's no

13:26knowledge base, we should skip them.

13:27Otherwise, we should send the reply

13:29automatically. I want you guys to see

13:31that on the left hand side, we had to

13:33spend months, maybe years, becoming

13:34skilled enough to use a platform to be

13:36able to build systems that did this. And

13:38on the right, a toddler who has a a

13:41rough idea in mind of what he or she

13:43wants to do can write it out in natural

13:44language. And not only can everybody

13:46else on a team interpret that, we can

13:48also change that at any point. If I

13:50wanted to add an additional step to my

13:51workflow, all I do is I click click on

13:54this, press enter, and then just write

13:55it out. and the agentic workflow builder

13:57and then eventually doer using a

13:59framework I'm going to run you guys

14:00through later on in this course will do

14:02it and it'll do it extraordinarily

14:03remarkably well. So that's a very

14:05fundamental change in how these things

14:07work and hopefully it's clear to

14:08everybody here that workflows are no

14:10longer drag and drop sort of builds in

14:13the concept that we see on the left hand

14:15side. They're very much so just like

14:17basic logic. So why is all of this stuff

14:20possible right now? It certainly wasn't

14:22just a little while ago. Well, there are

14:24three main reasons. intelligence, tools,

14:27and cost. On the intelligence side,

14:30model intelligence just crossed a

14:32threshold and became very, very good,

14:34seemingly overnight, but really we've

14:36been working up to it for quite a while.

14:38Frontier models like Anthropics Claude,

14:40OpenAs, Chat, GBT, Google's Gemini, and

14:42then a bunch of other ones have gotten

14:44really smart. They score around 80% on a

14:48benchmark called software engineering

14:49bench verified. And this measures real

14:51software engineering ability. This is

14:53not a crappy cherrypicked demo. It

14:56wasn't included in like the training

14:58data or anything like that. These are

15:00novel problems that are being solved in

15:01novel ways through models. And

15:03essentially, they are genuine

15:04professional grade work that are better

15:07than most software engineers. Now, I

15:09would have considered myself a software

15:11engineer a couple of years ago. I'd say

15:12my skills have definitely uh

15:14deteriorated a fair amount since because

15:16I've been focusing more on no code tools

15:17and and making money and stuff like

15:18that. But this stuff is so far beyond my

15:21own abilities as sort of like a

15:23mid-level dev u that it's not even

15:25funny. Most people that learn about this

15:27and they're going to be learning about

15:28it pretty soon will think that AI went

15:30from, you know, intern level to some

15:32sort of senior employee overnight. But

15:34this is just how knowledge works.

15:37Basically, anytime that you have a

15:39process and that process slowly gets

15:41better and better and better over time,

15:42most people don't see until we hit a

15:45certain threshold and then it almost

15:47looks like it went vertical. In reality,

15:49uh it's almost like the way that boiling

15:51water works, right? The temperature of

15:53water goes up and up and up and up and

15:54up and then eventually it boils and then

15:56it fundamentally changes state. You

15:58know, it goes from over here where it's

16:00like a liquid to over here where it's a

16:02a gas. And although we're supplying more

16:05and more energy to this thing, we're not

16:07really seeing it change until all of a

16:08sudden, boom, it's producing bubbles and

16:10getting all over the place. So, I see

16:12model intelligence a very, very similar

16:14way. So, a lot of people talk about

16:16benchmarks. Very few people actually

16:18show what the questions inside of a

16:20benchmark realistically ask. I think

16:22benchmarks are for the most part pretty

16:23artificial. A much better test of how

16:26good a model is is just how good you

16:27feel while using it. But it is important

16:29that at least we understand how

16:31benchmarks work in order for us to

16:32really put in context the capabilities

16:34of agents. So here's uh one from

16:36Astropi. It's a misleading exception

16:39message. And basically, these models are

16:41so good at coding. Like, like, I mean, I

16:43tried to look through and understand

16:44what any of these actual questions meant

16:46and how to fix them. I'd probably be

16:48staring at each of these for like a day

16:50before anything makes sense. Um, let

16:52alone before I get to the point where I

16:53could realistically solve it. These

16:55models can do this sort of thing in in

16:56seconds. So, issue problem statement.

16:58Hey, removing a required column from a

17:00time series raises a misleading error

17:01message. The error claims the time

17:03column is missing even when it's

17:04present. Instead, the error should list

17:06all missing required columns. Then it

17:08gives you a snippet of code with the

17:09actual class time series. Right? So

17:11looking at that, no idea what the hell

17:13that does. The bug, if flux is missing,

17:15error still complains about time. Error

17:17message is factually incorrect. You're

17:18fix detect which required columns are

17:20missing. Report them explicitly. So you

17:22actually have to go through and you have

17:23to do this with the code. Okay, here's

17:25one from sort of like a Panda style

17:27question. Load CSV silently coerces

17:30mixtype columns instead of failing

17:31quickly which leads to incorrect

17:32downstream computations and then it like

17:34provides a list. So, we now have models

17:36that are basically capable of looking at

17:38a thousand of these and solving more

17:42than 800 of them perfectly. I mean, if

17:45you gave me a thousand of these, not

17:46only would I take like a year, I would

17:49probably get at least, you know, 50% of

17:51these things wrong. And I'm somebody

17:53that has some exposure to this sort of

17:54stuff. Imagine the average person. And

17:57so what I mean to say is that we are

17:58essentially empowering every human being

18:01on earth or at least we have the

18:03potential to empower if we were to

18:04actually distribute this technology and

18:06if everybody were to know it to the

18:08level that you will know it by the end

18:09of this course with the powers of like a

18:11mid-level to even senior developer in

18:14many cases. Another important point is

18:16how fast these models can operate. I

18:19mean this is me asking chat GPT 5.2

18:21thinking to just reason a little bit

18:22about the meaning of life. Check out the

18:24stream of output that it's providing.

18:26But you can go way faster than that.

18:28This is an example of a diffusion LLM

18:30that it basically immediately processes

18:32and writes I don't know how many hundred

18:34words, but extraordinarily quickly. You

18:36see that we just click generate and then

18:37immediately after, you know, probably at

18:40least 300 words for instantiated. These

18:42models can run these reasoning loops

18:44extremely quickly behind closed doors.

18:46In addition, providers like uh Anthropic

18:48and OpenAI and Gemini and stuff have all

18:50the compute necessary to run these

18:51things like 10, 50, 100 times faster

18:54than you are yourself. So just imagine

18:56what's going to happen when that level

18:58of technology drips down to the rest of

19:00the economy. Like to be clear, these

19:02models, the ones that I'm using to build

19:03agentic workflows, are already extremely

19:05powerful and have automated the vast

19:07majority of my day-to-day work. They can

19:09automate the vast majority of your

19:10day-to-day work as well or any of the

19:12companies that you work with. But

19:13imagine the models in 3 months. Imagine

19:15the models in a year from now. That's

19:17why learning how to build these sorts of

19:19workflows today is probably one of the

19:20highest ROI skills that you can engage

19:22in. The second thing is tool integration

19:25is now standardized. So there's some

19:26protocols out there like model context

19:28protocol which standardizes how AI

19:31connects to external tools, databases,

19:33resources, and stuff like that. I'm

19:34going to be showing you guys how to use

19:36model context protocol in pretty

19:37advanced ways that I don't think a lot

19:38of other people have covered in this

19:40course. I'm also going to be talking

19:41about some of the downsides of model

19:43context protocol like how initially it

19:45totally blew but now it's uh actually

19:47pretty good and well supported so it's

19:48it's worth us diving in. In addition to

19:51you know those tools through MCP there

19:53also some frameworks that have recently

19:55come out. One is directive orchestration

19:57execution. This is the framework I'm

19:59going to be using to build and then use

20:00our agentic workflows throughout the

20:02course. There are also platform specific

20:04frameworks like cloud skills for the

20:05cloud family of models. these formalize

20:08tool calling and you know in case you

20:10have no idea what I'm talking about here

20:11LLM are really flexible okay which is a

20:13great thing conceptually it's great if

20:15you want to write poems and write do

20:16creative writing and help you respond to

20:18emails and stuff like that but a lot of

20:20business functions don't depend on

20:22flexibility what they depend on is the

20:24opposite they depend on reliability so

20:27in business we need to standardize and

20:29tools are basically just standardized

20:31little things that we can use in order

20:32to accomplish business tasks I like

20:35thinking of it like a caveman that you

20:36know, is hunting saber-tooth tigers or

20:38something. If you're a caveman and

20:40you're hunting saber-tooth tigers, and

20:42every time you go to a saber-tooth

20:43tiger, you're completely empty-handed,

20:45what are you going to do? The first

20:46thing you're going to do is you're going

20:47to be like, "Holy crap, is that a

20:48saber-tooth tiger?" You're going to

20:49scrge around on the ground to look for

20:51rocks and pointy stabby things and, you

20:53know, sticks and anything that can buy

20:55you some distance and then maybe some

20:56effectiveness. Contrast that with if

20:59before you had a little bit of foresight

21:01and you said, "Hm, I should probably

21:02build something that's kind of pointy

21:04and sharp." Huh? So, you you work all

21:06day and night and you put together a

21:07spear. Well, every time you encounter

21:09that problem of the saber-tooth tiger,

21:11okay, what are you going to do? You're

21:12just going to pick up your spear and

21:13deal with it. Just my really crappy

21:16drawn spear. That's sort of the same

21:17thing that LLMs use tools for. They

21:20encounter problems. When they encounter

21:22them a few times, they then develop

21:24tools that solve them or use

21:25pre-existing ones through MCP. And then

21:27in doing so, we can standardize the

21:29solving of business problems pretty

21:30easily.

21:32Okay. The last thing is just cost

21:33economics and they finally make sense.

21:36When Claude Opus 4.5 dropped, it went

21:38from a cost of about $15 or $75

21:41depending on input or output per 1

21:43million tokens to five or $25 depending

21:46on input or output for 1 million tokens.

21:48That's a 3x reduction. And newer models

21:50are even cheaper than that. The cost of

21:52intelligence per like effectiveness has

21:54plunged something like 40% in the last

21:56year. If I were to graph this, it would

21:58actually look like this. Now, I've been

22:00using models since GPT3, way back in

22:022020 when it was um initially released

22:05with a very small, you know, select

22:07group of people that could access it and

22:08so on and so forth. GPT3, which is, I

22:12mean, orders upon orders upon orders of

22:14magnitude dumber than this, costs more

22:17than this technology that we are dealing

22:18with right now. It is insane how quickly

22:21the price of knowledge work has

22:22plummeted. It's already gone down 40

22:25times in just the last year. I imagine

22:26it'll probably go down another 40 times

22:28over the course of the next year, maybe

22:29even more. What that means is we can

22:32actually send large volumes of tokens to

22:33these things to replace the work of like

22:36deterministic um old school automations

22:38like the NAN flow that I showed you

22:40without it running a business ragged

22:41into the ground. There are also tons of

22:43price wars that are occurring between

22:45major providers and there's a lot of

22:46like geopolitical incentives between,

22:48you know, places in the east and then

22:49places in the west um to basically make

22:51these things as accessible and easily to

22:53use as possible. So to make a long story

22:55short, this is new. Very few people

22:58understand the capabilities right now.

23:00So there are many billions of dollars

23:02that will shift as the market learns and

23:03adapts. It is much better to be an early

23:06mover than somebody that is affected by

23:08this technology uh without their consent

23:10or knowingness. What I mean is would you

23:13rather learn about this stuff now or

23:14would you rather learn about it in 2

23:16years when your boss or I don't know

23:18some some client base of yours turns to

23:20you and says hey we no longer need you

23:21because we have aic workflows to do it.

23:23I would much rather be the person that

23:25helps them build those agentic workflows

23:27than I'd be the person that's now

23:28sitting on my ass because I don't know

23:30anything about them. Hopefully, you are

23:31too. Okay, so now that that big

23:33preamble's out of the way, let's learn

23:34about chat bots, agents, agentic

23:36workflows, uh, knowledge tools, and then

23:38actually get our hands dirty with some

23:40demos. I like thinking about knowledge

23:41tools as evolving over the course of the

23:44last 30, 40 or 50 years. I always think

23:47about it sort of like the step ladder on

23:49the right where you have three rungs. At

23:52the bottom you have documents. In the

23:54middle you have chats and at the top you

23:58have agents. Over the course of the last

24:0030 40 50 years we basically transition

24:02from knowledge in the form of docs to

24:05knowledge in the form of chats over the

24:06last 5 years to knowledge and action in

24:08the form of agents. And I'm going to run

24:10you through what each of these look like

24:11now before actually using them in a real

24:13workflow. So documents are static

24:15knowledge. Hopefully they're pretty

24:16straightforward. It's oneway information

24:18flow. All you do is you read the

24:20document, but it's not like the document

24:22can respond to you. We currently use

24:24documents everywhere in school and in

24:25business. We use them in legal

24:26agreements. We use them in training

24:28materials. Once you write a document, it

24:29obviously stays fixed. That's a feature,

24:31not a bug, because it's great for

24:33permanence. Like if you're writing

24:34contracts or standard operating

24:36procedures that are immutable, aka it

24:38should not change. You don't want your

24:39contract or your standard operating

24:41procedure rewriting itself unless you

24:42want it to, right? In most cases, you

24:44don't. So, u that's great. That's

24:45actually a feature, not a bug. Chat

24:47bots, on the other hand, are not static.

24:48They are dynamic. Chat bots were

24:50developed realistically way back in the

24:521970s, but we were only starting to use

24:54them for real knowledge purposes and

24:56maybe like the early 2020s. And they

24:58perform two-way interaction. You read

25:00the output, but you can also ask

25:02questions back. So, here's a crappy pass

25:04to GPT40 where I just said, "Hey, what's

25:07up? Hey, Nick. All good on my end. Quick

25:08check-in. Zero fluff. I'm ready to help

25:10if you want to chat. If you got a

25:11decision to make, whatever. What's on

25:12your mind?" This is now two-way

25:14knowledge interaction. the dreaded

25:16mdash. Um, this allows you to do things

25:18like clarify confusing points. You can

25:20ask for research. You can dig deeper

25:22into topics. You can also modify the

25:24knowledge. So, you could upload, you

25:25know, a PDF or you could make some

25:26statement and then the chatbot now has

25:28some additional context. Uh, I just

25:30think of it like really smart colleagues

25:32who read everything you give them, but

25:33then they're also confined to a chair.

25:35You know, they can't move and they can't

25:36do anything with it. So, essentially all

25:37you can do is is talk. This is how most

25:40people treat models today as chat bots.

25:42They're dynamic knowledge, but they're

25:43still subject to this little window.

25:45They can only be communicated with and

25:47copied and pasted through your chatgbt

25:49or through your cloud output. Now,

25:50contrast that with agents, which I

25:52consider to be dynamic action. To make a

25:54long story short, this is two-way

25:56interaction, just like chat bots, except

25:57this time it acts. On the right hand

25:59side here, you can see I have a flow

26:01that says run the thumbnail generator on

26:02a link. So, it's not just asking it a

26:05question about the thumbnail generator,

26:06and I'm actually having it do something.

26:07And this is a real agentic workflow that

26:09I developed to basically build YouTube

26:10thumbnails like what you guys saw on my

26:12channel. What we see here is a

26:14fundamentally different interface. On

26:15the left hand side, we have some of

26:17these nodes. Green ones here are actions

26:19that are being taken. These gray little

26:21sections over here are thinking nodes,

26:23which are where the model reasons um

26:25extemporaneously, basically temporarily,

26:27and then discards these reasoning

26:28tokens. You can see that it's actually

26:30calling a script. You don't need to know

26:31Python in order to like have the model

26:33do really cool things for you, but

26:34that's what's happening right here. And

26:35then down over here we have a bash

26:36output where it's actually ran. We have

26:38an output that we can then use and so on

26:40and so forth. So you're given visibility

26:42into the reasoning. You're also given

26:43visibility into the um planning tool

26:46memory reasoning and then observation

26:48loop. And I'm going to cover exactly

26:50what that looks like in a moment. You

26:52also have autonomy, long execution

26:53times. Agents can routinely run for 5 or

26:5510 minutes. Now yesterday night I

26:57actually had an agent run for over 5

26:58hours uninterrupted to build me a really

27:00cool system. As of today I think of

27:02models like a mid-tier developer.

27:04They're 100K a year or so in terms of

27:06their like capability. But if you think

27:07about it, I'm spending 20 bucks a month

27:10for this, which is 240 bucks a year,

27:12which is over 400 times cheaper. And not

27:14only is it cheaper, this thing works 24

27:16hours a day, as I mentioned, or it can

27:17work 24 hours a day. You can do a lot of

27:19really cool things with models like

27:20this. So now is the time to jump on it.

27:22A point to understand is that an agent

27:24is not a chatbot, despite the fact that

27:25they look really similar, right? Now,

27:27the way I see chat bots is like a chat

27:29is just an interface, right? It's just

27:31some specific thing with messages that

27:33go back and forth and then a little

27:34window down here where you can enter in

27:36your own information. The chat is just

27:38like the app. The agent is what lives

27:40inside of the app. If you guys are

27:42familiar with crustaceians or crabs or

27:44um I don't know, like cute little things

27:46that crawl around on the ocean subfloor.

27:48They often will have fine shells and

27:51then um discard them when they no longer

27:53fit their purpose. Right? So, like a

27:55crustation that uses the shell of an

27:57older animal, an agent is just currently

27:59using the interface of an older type of

28:01knowledge tool, the chatbot. And I'm

28:03sure over the course of the next few

28:04years, it's going to discard this and

28:05we're going to have new interfaces that

28:06are even better. Okay, so let me show

28:07you guys just the difference between

28:09chat bots and then a really low-level

28:10agentic workflow that I put together

28:12that functions through an agent. Um,

28:13down over here is a chat GPT desktop

28:15app. This is really simple and easy. You

28:17can download it on chatbt's website.

28:18Super straightforward. I'm just going to

28:20say um hey, how can I scrape, you know,

28:23leads from LinkedIn Sales Navigator. So,

28:27when you're working with models like

28:28this, the input and output is pretty

28:30bounded, right? All you can really do is

28:32you could just see what this model tells

28:34us. Hey, you know, here's the direct

28:36high IQ zero fluff rundown. Use this,

28:39scrape this,

28:42use this. This is cool, right? I mean,

28:44it's nice that we're getting information

28:45on how to do this. And you know a few

28:46years ago this would have been

28:47revolutionary. Rather than just have a

28:49conversation with the model and ask it

28:50how to do things which is knowledge. I

28:52can actually force a model to action

28:54using agentic workflows. So in this case

28:56I'm saying scrape me 200 HVAC owners in

28:58the US. I want decision makers. It then

29:01checks to see if there are lead scraping

29:02directives and execution scripts. This

29:04is just part of the framework that helps

29:06constrain the model's output which I've

29:08run you guys through a little bit more

29:09later. It's then going through and

29:11actually pulling a script together to do

29:13this thing for me. It then comes up with

29:15this idea of a test scrape, 25 leads.

29:17It's then going to verify some industry

29:19match, run the full scrape, upload to

29:21Google sheet, and then even go through

29:22and enrich it for me. In this case, the

29:24model is performing a search. It's then

29:26comparing the results of the search with

29:27what it is that it thinks that I want.

29:29It's determining that there's a very low

29:31match rate. And so, it's now adjusting

29:32its filters on the fly completely on its

29:35own to find leads with zero input. All

29:38I'm doing here is texting a friend of

29:39mine on my phone.

29:42It's then verified, past threshold. Now

29:44it's running a full scrape. It then went

29:46and it actually got us a Google sheet

29:47with all that information. I mean, it's

29:49pretty cool in so far that it's totally

29:50autonomous. It probably would have taken

29:52me a fair amount of time to come up with

29:53the filters and so on and so forth

29:54myself. This thing just did it entirely

29:55on its own. If you guys check the bottom

29:57right, we actually ended up getting

29:58almost 200 emails directly from this. We

30:00also got a bunch of phone numbers and a

30:01bunch of other really personal

30:02information. So, what exactly is going

30:04on? There are five steps that an agent

30:05will follow every single time you send

30:07or receive a message. The first is

30:09planning. The next is tools. The third

30:10is memory. The fourth is reflection. And

30:12the fifth is orchestration. I think I

30:14called it observation before. My bad on

30:16that. But orchestration. I use a simple

30:18fiveletter acronym for this. Just pt

30:20mro. Helps me remember it. Hopefully

30:21it'll help you remember it as well. Now

30:23these five components are as follows.

30:25Planning is where you break down

30:26objectives into executable steps. Tools

30:28are the actions that an agent actually

30:30takes in the world. If you guys

30:31remember, it was calling various things

30:33to do what it needed to do. They then

30:35stored things into memory. So this is

30:37how agents retain and recall information

30:39across tasks. There different forms of

30:41memory. There's short-term, midterm,

30:42long-term, and there's different ways

30:44that that works within an agent these

30:46days. I'm I'm going to cover each of

30:47them. Uh reflection is where the agent

30:49evaluates and corrects its own work. So,

30:51as you saw there, we had an issue with

30:52one of the calls and it went through and

30:54it fixed the filter. And then finally,

30:56orchestration, which is where you

30:57coordinate multiple agents or complex

30:59workflows. We're going to talk about how

31:00to do that um later on in the program,

31:02too. Obviously, there's planning, and

31:04that's mostly goal decomposition. So,

31:05it's where a highle objective gets

31:07broken into subtasks. Um, for instance,

31:09if your highle task is to eat at White

31:11Castle, you know, it's not just eat at

31:13White Castle, right? That's not enough

31:15to go and actually do the thing. What

31:17you want to do is you want to break that

31:18down into various tasks. Like maybe step

31:21one is we have to um, I don't know, get

31:23in the car, right? Step two is, and

31:26maybe you do this while you're in the

31:27car, you do this before, you got to

31:29research the um, GPS location. You know,

31:32the third is you have to drive all the

31:34way over there.

31:36And then the fourth is you actually have

31:37to order. And the fifth is you have to

31:40make a movie about it. Just kidding. But

31:42um the point that I'm making is you know

31:43you take this high level task and you

31:44actually break it down. And that is

31:46occurring every single time within an

31:47agent. You don't always see it because

31:49it's typically buried within reasoning

31:51and most people don't expose reasoning.

31:52But this form of highle goal

31:54decomposition occurs all the time. And

31:56it's important that it does it right

31:57because if it screws up at the planning

31:59stages, probability of it being able to

32:01move and do the rest of the task is very

32:03low because it's making a foundational

32:04misassion. Now, an agent will identify

32:06dependencies within steps. It'll then

32:08sequence them logically, like I just

32:09gave you, five steps. Well, the agent

32:11will actually reverse those steps as

32:12necessary. And then good planning also

32:14means revising the plan when things

32:15change because there's obviously only so

32:17much information that we have ahead of

32:18time. There are limitations to this and

32:20Claude, GPT, Gemini, these have pretty

32:23imperfect planning capabilities. So, as

32:25part of the building of the workflows

32:26that I'm going to show you later, I

32:28actually recommend doing a fair amount

32:29of the planning yourself. The reason why

32:31is because it's sort of um like an

32:33analogy where if I'm on I don't know

32:36let's say the east coast of the United

32:37States and I want to go somewhere on the

32:39west coast of Africa or something like

32:41that. Okay, and I'm this ship over here

32:43and my goal is I want to make it to this

32:45port right over here. If I screw up at

32:48the very beginning, okay, even by a few

32:51percentage points, let's say, okay, and

32:53I give myself a range of possible

32:55outcomes here, this range, even if it's

32:57like a 1% problem with the planning or

32:591% error or something like that, these

33:01ranges have massive downstream impacts

33:04over the course of the entirety of the

33:05task. Like, if I'm really really bad, I

33:08could end up in the middle of freaking

33:09nowhere. Or if I'm really, really,

33:10really bad on this end, I could end up,

33:12you know, hundreds of kilometers, maybe

33:13thousands of kilometers away from where

33:15I wanted to go. So what planning really

33:17is if you think about it is effective

33:19planning just reduces those error bars.

33:21It just allows us to go a lot tighter

33:23and a lot narrower. So the probability

33:25of us actually achieving uh the thing we

33:27want aka going to where we want to go is

33:29a lot higher. If there was one place for

33:31you to exert your human intellect, it's

33:33at the planning stage. And I'll cover

33:34some practical ways to do that later. Um

33:36obviously there's DO which helps by

33:38providing structured directives. I'm

33:40going to show you guys how you can just

33:41dump your company SOPs into a model to

33:42guide its planning. If you guys don't

33:44have company SOPs, I'm going to show you

33:45how to reproduce them really simply and

33:46easily. Next are tools. Now, these turn

33:48LLMs into systems that are capable of

33:50real world action. Um, I think I covered

33:52the caveman analogy, ancient people

33:54building a spear or something like that,

33:56but you can also think of it as like an

33:57ancient person building a house. It's

33:59like they will build the house the first

34:00time and the house will be pretty cool,

34:02you know, might um have most the things

34:03that they want. I don't know, some sort

34:05of um straw roof or whatever. And then

34:07what's really cool is agents can then go

34:09back to the tools and then make them

34:10better. So maybe, you know, you want to

34:11build a window or something like that.

34:13So the first iteration of the house

34:14doesn't have a window. Second one has a

34:15window. The third one has like a door.

34:17The fourth one has like a cool barbed

34:19wire security system and so on and so

34:21forth. But just to break it down, tool

34:22use is where agents interact with

34:24systems and services. In our case,

34:27because we are dealing mostly with

34:28digital services, that means things like

34:30calling APIs. Okay, that's a big chunk

34:32of tool use to be honest. Then executing

34:34code. You don't need to know any of the

34:35code. It does the coding for you, but it

34:37is still executing the code. It also

34:39nowadays includes a lot of database

34:40stuff because you don't want to store

34:42all the information directly in the uh

34:44context of the model. Then it also means

34:45things like browsing the web. So if your

34:48computer was the entire world, right, in

34:50your case, the tool that you personally

34:52use to interact with your computer, if

34:54you think about it, is use your mouse

34:55and use the keyboard. And some people

34:57are now using voice transcription tools

34:59like myself. So that is our input method

35:01to our world of the computer, right?

35:04Well, it's the same thing with agents.

35:05Tools are their input methods to real

35:08life. They need tools in order to break

35:10out of that little chatbot, okay, and

35:12actually influence things that matter.

35:14So the entirety of the intelligence of

35:16models in the do directive orchestration

35:19execution framework in cloud skills in a

35:22bunch of these different ways of

35:23thinking about agentic workflows, the

35:25entire point of the intelligence is just

35:26to help it use and then build tools. And

35:29a good analogy is tools are like the

35:31agents hands. The LLM is the brain. If

35:33you're a brain and you're in a vat or in

35:34a jar somewhere, obviously your ability

35:36to influence the real world is pretty

35:37limited, right? But you give a brain

35:39some wires and neurons and some hands or

35:41whatever and now it can actually start

35:42doing things. Unfortunately, right now

35:44tool quality varies a ton. There is a

35:46lot of variance in like really good and

35:48really crappy tools. And just a few

35:50months ago is actually way larger.

35:51There's way more variance, but we're

35:52getting better. And I imagine future

35:54tool systems are going to be mostly

35:56pretty solid. There's going to be a lot

35:57less uh uh range between like a really

35:59good tool and a really bad tool.

36:01Essentially, um, this is for a variety

36:04of reasons. MCP came out pretty

36:05recently, and there are also a lot of

36:07people trying to capitalize short-term

36:09on MCP, so they're building a lot of

36:11really crappy tools. I'll show you guys

36:12how to avoid that, and also how to

36:13select like really high quality tools

36:14that matter, as well as how to build

36:16your own that are way better. The way I

36:18see bad tools is it's like if you give

36:19somebody a really crappy hammer and then

36:21you expect them to build you like a

36:22really nice uh cupboard or cabinet or

36:24something, probability is low, right? If

36:26you want to build something really cool,

36:27you need to have cool tools. If you want

36:29to do something really cool, you

36:30obviously need to make sure those tools

36:31are as high quality as humanly possible.

36:34So, here's one of the key insights of

36:35Agentic Workflows and one of the reasons

36:36why I think a lot of people don't

36:37understand how the stuff works. When you

36:39standardize tools, okay, and you turn

36:41them from vague ideas into actual

36:44concrete functions. You let anybody use

36:48them, regardless of the type of model

36:50that you're using, whether it's Claude

36:51or whether it's chat GBT or whether it's

36:53Gemini. All of these models are smart

36:55enough to know how to use the tool. You

36:57also ensure consistent inputs and

36:58outputs, which is really, really

37:00important for business. And the cool

37:01thing is you don't actually need to wait

37:02for other people to build them anymore.

37:04All of these models are hyper optimized

37:06for programming. So, we're just going to

37:08let the model build its own tools. LLMs

37:11are very probabilistic, right? Their

37:13decision-m process is pretty opaque to

37:15us. I heard a great quote the other day,

37:17uh, might have been from Dario Amod,

37:18might have been from somebody else, but

37:19it was that AI models are grown. They're

37:22not built. And I think about that pretty

37:24often. AI models are just intelligences

37:26that we are slowly figuring out how uh

37:28they work under the hood. We don't

37:30actually know. We don't have an an

37:31established consistent decision-making

37:33process that takes us from one to

37:35wherever we want to go. Business

37:37requires that you need interpretability.

37:39You need the ability to audit things and

37:40so on and so forth. Okay? So rather than

37:42have this big probabilistic galaxy brain

37:44which makes decisions in routes in ways

37:46that we have no idea how, okay, we just

37:48give it very very simple tools. And in

37:53that way, even if there's some

37:54deviation, maybe it gets all kind of uh

37:57loopy over here, we know that it called

37:59a tool. And because it called a tool, we

38:01can obviously interpret that um a lot a

38:03lot easier, right? We have a sequence of

38:05steps like 1 2 3 4 5 6. We go through

38:09the process. It's just way more

38:10straightforward. So, we just let an

38:12agent, which is optimized for coding,

38:13make its own tools. Then the agent will

38:16call the tools and then interact with

38:17life for us. I want to show you guys how

38:19easy it is to build your own tools. So

38:21here I have a simple query. Hey, how

38:22would you build a workflow that takes a

38:24video, cuts out the silences in said

38:26video, and stitches it all back together

38:28to deliver me the results. The cut

38:29should look natural like most YouTube

38:31junk cuts. Basically just try and stitch

38:32the empty space together. You know, this

38:34is a pretty complicated flow if you

38:36think about it. There are a lot of

38:37different ways you could build something

38:38like this and none of them are basically

38:40easy. So, what this is going to do is

38:41it's going to look for a couple of

38:43simple and easy ways to do this and then

38:45present them to me because I went down

38:47here and I selected plan mode, which is

38:48one of the different modes that you can

38:49use in um at least the Claude series of

38:51models. Keep in mind depending on the

38:53models that you're using may be a little

38:54bit different. So now once I have this

38:56plan in front of me, I'm then going to

38:58be able to decide on how to do the

38:59workflow and then I could act as more or

39:01less a highle director letting this

39:03thing know whether or not I want to do

39:04something. Okay, next up it's asking me

39:06are we doing this on short clips, long

39:08clips, any preference on the defaults

39:10and so on and so forth. I say short

39:12clips defaults sound fine. MP4 is great.

39:17Okay, I then have the plan in front of

39:18me and if I wanted to build this, all I

39:20would need to do is click yes and auto

39:22accept. And I think I will. That seems

39:24pretty straightforward. So, let's give

39:25it a try. While this is working, I'm

39:28just going to see if I could find an

39:29example of a video that I could feed

39:31into this. Um, I've done this a couple

39:33of times previously as you guys could

39:35see. So, let me just find some really

39:37simple video that's only a few seconds

39:38that we can test this on. Okay. And I

39:41found an example here. It's just a short

39:43one minute video clip of me doing a

39:45typical intro.

39:47Now that this thing is building, I'm

39:48just going to move this to bypass

39:50permissions mode. That'll just allow it

39:51to operate autonomously without me. And

39:53once it's there, it's actually created

39:54it. That's great. As you guys can see,

39:56that only took us maybe like 30 seconds

39:58or so. From here, I actually want to

39:59test this. Let's test using

40:02test_clipip.mpp4.

40:07Now, I'm not actually expecting this to

40:09work the first time around because most

40:10workflows don't actually work the first

40:12time around. It's all a process of

40:13progressive iteration. Essentially, if

40:15the workflow doesn't work, the error

40:17message is fed back into the agent and

40:19then the agent will progressively build

40:21the agentic workflow using the u the

40:23error messages to sort of guide it in

40:24the right direction.

40:26In situations like this, I honestly just

40:28alt tab and then do something else.

40:30Okay. And it actually looks like it did

40:32run through the entire test manually and

40:34was perfectly fine. That's crazy. What

40:37I'm going to do now is I'm just going to

40:38watch the test, see how it is, and then

40:40we'll just continue to go back and forth

40:41a few times until I have what I want.

40:43Oh, by the way, I don't even need to

40:44find this file. I could actually just

40:45say open it. Okay, so I'm noticing that

40:48the cuts are kind of abrupt. They're a

40:49little bit too fast for me. Um, what I

40:51mean by that is like instead of cutting

40:53at the point that I wanted it to cut,

40:55it's just cutting like a few seconds

40:56before. Multiple different ways around

40:57this. I could use a different approach

40:59to detect the cut points. I could have

41:01it manually move things over. I mean, if

41:03you think about it, like I could do

41:04whatever the heck I want here. Uh, this

41:06thing's operating at the speed of

41:07thought. So, I'm just going to give it

41:08some very high level instructions here,

41:09and we'll see what it thinks. It's

41:11giving me a bunch of different options

41:12here. One of them is voice activity

41:14detection. I like this. Let's do this

41:17one. Okay, it's now testing with this

41:18new approach.

41:20All right, let's take a look at round

41:21two.

41:24Okay, so it worked perfectly on the um

41:27one minute clip. So now I'm just going

41:28to run it on test three minutes.

41:32Okay, and it's just finished and then

41:34opened the next clip. Let's just see how

41:36that does. There is a cut point right

41:39here, I think. Let's see if that's good.

41:44Cool. Nice. Looks like it did that cut.

41:45That's cool. How about another one? H

41:49I think it was right here.

41:54Nice. It's solid.

41:59Last one right here.

42:04Cool. So, yeah, this one worked

42:05basically perfectly. Um the agentic

42:07workflow is for the most part now

42:09complete. So, you guys could see it took

42:11one back and forth. I just in a very

42:12high level um realistic way gave it a

42:15list of what I wanted. I didn't really

42:16know what I wanted to be honest, just

42:18like I think most people that have

42:19probably done any sort of like software

42:20engineering work know clients usually

42:22have no clue how to scope a project. So

42:24you can sort of only take them at face

42:25value there. I went back and forth a

42:27little bit. Um you know I was like okay

42:28this didn't work too well. Is there any

42:30other thing that we could do? It gave me

42:31some other thing. So I tried the other

42:33thing. Hopefully you guys could see that

42:34this sort of loop is very

42:35straightforward and realistically only

42:37takes a few moments of your time. The

42:39most important part I think of my entire

42:41day is now just providing some sort of

42:43highlevel nudge in one direction or

42:44another to a agents like this when

42:46designing my agenda workflows. Um, you

42:49know, like if you just remove me from

42:50the loop completely, the resulting agent

42:52workflow is probably going to suck, at

42:53least for now. But, uh, I'm just here to

42:55steer the ship, right? It's almost like

42:57as if I don't know, it's like an old

42:59school Viking boat where people have to

43:00like manually row, right? So, I'm just

43:02the person at the very front of the ship

43:03doing a little bit of steering. The

43:04agents are the minions doing my rowing.

43:07At this point, I'm briefly going to

43:09cover memory here. It's how agents

43:10maintain context. This isn't super

43:12important to know for building, but it's

43:14important to know if you want to

43:15understand how these things work under

43:16the hood. So, short-term working memory

43:18are basically reasoning tokens that are

43:20relevant to the current task. They're

43:21stored temporarily. If you guys have

43:23ever seen like a little thinking window

43:25or a thinking tab with like a little

43:26thing that you could click to open

43:28inside, it'll be like the user wants to

43:30do this. The user is thinking about

43:31doing this. This is your uh short-term

43:33memory sort of uh analog and like the

43:35way that our human brains work. Sort of

43:37your intermediate memory is your back

43:38and forth messages with the agent. So

43:40it's like the actual like message chain

43:42that you are having. Those aren't

43:44removed like reasoning tokens are. And

43:45so this is just always stored and sent

43:47with every API call. Long-term memory

43:49are things that persist across sessions.

43:51So they're variables that are stored in

43:52claude chat GBT etc. On the right hand

43:54side here, I have that same message that

43:56I sent earlier as part of our demo where

43:58I scrape 200 HVAC owners. If I show you

44:00guys how all of this memory works in

44:01context, basically this over here, okay,

44:04and then its replies are what are called

44:06intermediate messages. Anything inside

44:08of this thinking tab is like your

44:10short-term, okay? And then long-term are

44:13like things that are stored within my

44:15file space. So they're things like, you

44:18know, my agents MD. They're things like

44:20my Gmail accounts.json. They're things

44:22like my token leftclick. If this all

44:25seems like magic to you right now, don't

44:26worry. You're going to get to the point

44:27you can actually understand and

44:28interpret everything within an

44:30integrated development environment by

44:31the end of the program. But I just

44:32wanted you guys to be on the same page

44:34here that this over here is like an

44:36intermediate piece of memory. It's going

44:38to include all messages that are sent

44:40and received from you and the agent and

44:41then everything in between the reasoning

44:43loops and stuff for short-term whereas

44:44long-term tend to be files and then

44:46system prompts. Right now, one of the

44:47primary failure modes in Agentic systems

44:50right now is because of um context. And

44:52context, for those people that don't

44:53know, is just all of like the the

44:55letters and words and tokens that are

44:57being stored in a model at any given one

44:58point in time. Uh the way that agents

45:00manage context limitations right now is

45:02they are summarizing previous steps to

45:04save on tokens by compressing the full

45:06history into key takeaways. If you think

45:08about it, like the way that I write and

45:10the way that the model writes isn't

45:11actually like super token efficient.

45:12What it does is it makes a bunch of

45:14summaries of these constantly. So if you

45:16know this is my actual chat window if

45:18you think about it that's the message

45:19that the agent sent me and this is the

45:21message that I sent the agent this is

45:22the message that it sent me back and

45:24blah blah blah what it'll do

45:25periodically just to save on the token

45:27cost is it'll actually just summarize it

45:29in as high density a form as humanly

45:31possible so we take maybe like a 500word

45:34uh uh context and then chunk that down

45:36into like a a 100 or maybe a 50word

45:39context. It'll do so periodically

45:41without losing you the core details just

45:43by rewriting it in various ways that are

45:44just a lot simpler. For instance, I

45:46could say hello, how are you doing? My

45:48name is Nick Sarif. Or I could say, hi

45:52dash, how you do question mark, I'm Nick

45:58Sarif. And if you just like count up the

46:00total number of characters there, the

46:01latter one is obviously going to be a

46:02lot more efficient. They also don't

46:04store reasoning in the main loop. It

46:06generated temporary and then it

46:07disappears. It does store intermediate

46:08results externally by offloading the

46:10databases, files, and other vector

46:11stores. And then it'll now load the

46:13relevant context on demand to only pull

46:15in what is needed for the current step.

46:17Um, you know, you can build this in

46:19explicitly using something called a rag

46:20or retrieve augmented generation system,

46:22which I'll talk about later, or you can,

46:24uh, you know, just let the model do its

46:25own thing and it does a pretty good job

46:26of it. When we make it to reflection,

46:28this is where the agent self-evaluates.

46:30So that's where it examines its outputs

46:31to detect errors and then assess whether

46:33or not what it wanted to do actually

46:35worked. It identifies the approaches are

46:36failing. it knows when to pivot and it

46:38just selforrects. This is really like

46:40the intelligence of the model to be

46:41honest. Um, if you don't have this

46:43reflection loop, you will just have a

46:44script like a typical Python script or

46:47like an nadn or make.com or zapier or

46:49gum loop or lindy automation that just

46:51breaks at the first hiccup. And this is

46:52also really important in what's called

46:54self-annealing which I'm going to cover

46:55a little bit more of later. But it's

46:56essentially the way that an agentic

46:58workflow can run and then also just heal

47:00itself as it encounters errors and so

47:02on. Finally, we have what is called the

47:03orchestration or coordination layer. The

47:05way that I think of it as if you just

47:07get all of these steps, right? So

47:08planning, tool use, memory, then

47:12reflection. Okay, orchestration doesn't

47:15exist within the loop. It sort of exists

47:16outside of it or maybe inside of it. And

47:18then it's just responsible for shuttling

47:20the information around from step to

47:22step. And that's really cool, right? It

47:24looks at the results of the plan. It

47:27then feeds that into the right tools. It

47:29then enters what it needs to enter in

47:31memory. and then it looks at the results

47:33of the reflection and then changes the

47:35next loop of the planning and so on and

47:37so on and so forth infinitely. I think

47:38of it as like the brain that combines

47:40all the components that we just talked

47:41about similar to how your brain combines

47:43inputs from like your ears and your eyes

47:45and your nose and your skin and your

47:47mouth and your memory and it just like

47:49factors everything in and then this is

47:51what thinks and then ultimately comes up

47:53with decisions. Now there are a couple

47:54of different approaches uh right now for

47:56orchestration. uh there's an approach

47:58with crew AI right now that uses

48:00role-based team structures and so you

48:02know up at the top you have some sort of

48:04manager and then underneath you maybe

48:06have like a a marketer and then you have

48:08like a software engineer and you know

48:10the manager exists above the marketer

48:12and the software engineer and the

48:13marketer has like you know some interns

48:15and so on and so forth the software

48:17engineer has some juniors this is one

48:19way of doing it um and it's a way that

48:21you know crew AAI has done reasonably

48:23well with like the sort of framework

48:25role-based team structure I think It's

48:27kind of like an organization and I think

48:28that's just looking at things like a

48:30human being would. I think they're

48:31actually just much more efficient ways

48:32to organize. So I don't personally do

48:34this with the directive orchestration um

48:36execution framework and then cloud

48:38skills. Instead, what we do is we

48:40basically give AI access to um both

48:43highle instructions and then tools to

48:47have it execute. And then this AI over

48:49here, this is sort of like that

48:50orchestrator that we were talking about

48:52before. It just looks the high level

48:53instructions, looks at the tools,

48:55matches up the two, does stuff, stores

48:57things into a memory, and then it just

48:58loops over and over and over in that

49:00PTML loop. Claude skills is kind of

49:02similar. It just um organizes the

49:04instructions. If we visualize this for

49:08you guys, it basically just stores

49:09things into a folder. This folder

49:13contains both the highle instructions

49:15and the specific tool use and any

49:18additional resources. And then the model

49:21now just accesses a folder instead of

49:23accessing you know two different

49:24folders. And really the point I'm trying

49:26to make is no framework is perfect yet.

49:28I imagine the real best framework in the

49:30future is just going to be a combination

49:31of all these. You know taking the best

49:33parts and leaving the crappiest parts.

49:34Um but they are all improving rapidly as

49:36the space gets m more and more mature.

49:38So my recommendation is we're not going

49:40for perfection here. We just want what

49:41works. And in my case um I use dough

49:43because you know I came up with it and

49:45then it's a big part of all the content

49:46that I'm producing now. So I mean this

49:48works reasonably well right now. Sure,

49:50maybe there's another framework out

49:51there that'll get us from 97% accuracy

49:53to 98.5. I'll worry about that framework

49:56when it's here. For now, I'm going to do

49:58what I can with the 97. Okay, we're now

50:00talking text. This is the universal

50:02interface. When I want to talk to my

50:05model, I do so through text, right? When

50:08I want to talk to my model and I don't

50:10know, I try and give it a call or

50:12something like you can do on claw on

50:13chatbt and stuff like that. What's

50:15really occurring is I'm transcribing

50:16most of that into text. Now agents if

50:19you think about it are actually a step

50:20back in terms of our interfaces for now.

50:23Back in the day and when I say back in

50:25the day I mean like you know very very

50:27recently um most people use these drag

50:29and drop no code tools right and these

50:31are actually really pretty and they're

50:32very easily interpretable and you can

50:34see how the data flows and so now we

50:36basically said no screw that we just

50:38want a bunch of words on a screen right

50:40which obviously has a bunch of issues in

50:41terms of presentation our ability to

50:43visualize them and understand them.

50:44Right now we are taking a step back in

50:46terms of the interface. It's sort of

50:49like back in like the 70s, 80s and 90s

50:51when most people coded and then built

50:53things on computers through DOSs or

50:55Linux terminals, right? It was like text

50:57in you get results out. That's it.

51:00Everything is just like some sort of

51:01terminal or prompt. And in this way, I

51:03think it can be really intimidating for

51:04people because they just see a bunch of

51:05text and they're like, "Oh, I'm not a

51:06programmer. Oh, I'm not like a, you

51:08know, I don't learn through reading and

51:09writing. I learn through seeing." And I

51:11think that's fair and it's a totally

51:13okay criticism to make with these things

51:14right now. I imagine future systems are

51:17going to go back to a visual interface.

51:19It's just we don't have them yet. And as

51:20I mentioned earlier, my whole goal is

51:22just make do with what we can at the

51:24moment. I imagine over the course of the

51:25next couple years, somebody's going to

51:26build the most amazing visual interface

51:28probably in conjunction with one of

51:30these agents or agent agentic workflow

51:32builders and then we'll have something

51:33that combines the best of both worlds,

51:35natural language and visualization. But

51:37right now we use some tools. And those

51:39tools as of the time of this recording

51:40are cursor, VS code, and anti-gravity.

51:43And that's where most agent interaction

51:45happens today. That is the textheavy

51:47interface that you guys saw earlier as

51:48part of the demo where I just talk to

51:50the model through a chat box and see it

51:51update files and stuff like that. On the

51:53lefth hand side, I have some

51:54recommendations to make things feel a

51:56little bit more natural. I personally

51:57use speech to text tools like um Whisper

51:59Flow and Aqua. These are really simple,

52:01straightforward transcription tools.

52:03They allow you to feel like you're

52:04talking to an employee more than you are

52:06necessarily writing text or typing at

52:09your computer. I'm going to show you

52:10guys a bunch of practical examples of me

52:12using this. But for now, let me give you

52:14guys a demo. On the left hand side here,

52:16I'm just talking to my model. I

52:17basically converted a workspace from the

52:19directive orchestration execution

52:21framework to the cloud skill framework.

52:22And you guys are going to see both of

52:23those later. But for now, I just want to

52:25ask it how things are going and you

52:26know, if you can tell me something about

52:27it. So, I'm just going to hold down a

52:28key on my computer. Fn. Hey, can you

52:31tell me a little bit about the changes

52:32that we just made? I let go and then I

52:34press enter and now I'm basically

52:36talking to my model. Of course, I still

52:37have to press the enter key. Future

52:39iterations of this will probably change

52:41that, but in this way, I'm maximizing

52:43the bandwidth. Human beings can speak a

52:45lot faster than they can type, but they

52:47can also read a lot faster than they can

52:48listen. So, this is typically how you

52:50optimize both of those. All right, so

52:51what I have here are five cloud code

52:53instances. I'm running the latest model

52:55of Opus, Opus 4.5, at least as of the

52:58time of this recording. You guys may

52:59have some later versions, but just to

53:01show you as the variability of model

53:02outputs, I've set all these to plan

53:03mode. And what plan mode essentially

53:05means to make a long story short is they

53:07just don't they can't take actions

53:09without my express or explicit approval.

53:11They write a plan for me first, then I

53:12verify the plan. And so, just to show

53:14you guys how different um various forms

53:16of these plans are, I'm going to open up

53:19five tabs. I'm then going to um open up

53:22the reasoning and kind of thinking

53:23panels here. Then we're just going to

53:25evaluate how different all of these

53:27answers are to the same simple question.

53:30What are some ways to send automated

53:31proposals? So I sent that to all five.

53:33And you'll see that as we proceed

53:35through here, there are a variety of

53:38different routes that these models

53:39follow. After this does its research and

53:41and plans, you end up with five answers.

53:44And you'll notice that um all five of

53:46these answers are different, meaning

53:47that there is no like procedural

53:50simple step-by-step result here. the

53:53models are doing different things every

53:54single time. This first one here says,

53:56"What type of proposal?" So, it's asking

53:58me some questions. The second one here

53:59actually just went through and then

54:00wrote me a big list of different options

54:02I could take. This third one here wrote

54:04me sort of a combination, ask me some

54:06questions. And then it's giving me some

54:08common automation triggers alongside

54:10some more questions. This one here gives

54:12me these four options. And then this one

54:14here gives me like a little table. And

54:16this is okay. I mean, obviously I'm

54:18arriving at like the same sort of answer

54:20regardless, but I want you guys to know

54:22that like the way that businesses work

54:24is, you know, when somebody does

54:25something like they fill out a form or

54:27they require an invoice sent or

54:30something of that nature. This level of

54:32variability in and of itself is way too

54:33much. There's no way that we could

54:35really like meaningfully add value to a

54:37business, whether it's our own business

54:38or some other business with variability

54:40like this, with like 30 40 50% variance

54:43in answers. What we need is when we

54:45generate an invoice, the invoice needs

54:47to be basically the same every time.

54:48When we generate a receipt, the receipt

54:50needs to be the same every time. When we

54:52send an email, maybe an onboarding thing

54:54or whatever, these should be the same

54:56every time. When a new form comes into

54:58our system and we need to qualify them,

55:00we should use the exact same

55:01qualification framework every time. Any

55:03serious company at scale that has this

55:05level of variability in their processes

55:07won't be a serious company for long.

55:09which is why raw large language models

55:11are very difficult to use in u both

55:14mid-market and enterprise style

55:15applications. Now the reason for this is

55:17because LLMs are probabilistic not

55:20deterministic. I touched on this earlier

55:22on in the course but let me run you

55:23through how a large language model

55:25actually works under the hood. So a

55:26while back I actually built a large

55:28language model. Well I guess kind of a

55:29small language model. this guy Andre

55:31Cararpathy, he um built this big uh like

55:34GitHub repo showing people how to like

55:36train their own textbased mini GPT. I

55:40went through this whole thing and then I

55:41built my own mini GPT and it was really

55:42instructive and I've since learned a lot

55:44more about large language models and

55:45sort of what's going on under the hood.

55:47So let me just give you guys a very

55:48brief demonstration. If you guys

55:50understand this, you guys will go a lot

55:51further towards getting how these agents

55:53are working under the hood. What large

55:55language models are are they are

55:57basically machines and they are machines

55:59that operate off of a distribution of

56:02outcomes. What I mean by this is they

56:05are statistics sort of pattern matchers.

56:07What a lot of people think is that large

56:09language models will predict the single

56:11best next word but they don't do that.

56:14Instead they predict a statistical

56:16distribution of options that they could

56:17pick from. What I mean is if I say hi,

56:21how are and then I have a little space

56:26and if you feed this into a model, what

56:28you may think you're going to get is

56:30you're going to get the most likely next

56:31token, right? Which is sort of like

56:32universe A. You think you'll just get

56:33the word you and then maybe a question

56:35mark. But what you actually get is you

56:37get a whole graph

56:39of different outcomes and possible words

56:42that you could choose from. This one

56:44might be you. This one might be

56:49the word things, right? How are things?

56:52This one here might be your, for

56:54instance. And what happens is we use

56:57this concept of temperature and top P to

57:02basically randomize the process of

57:04choosing the next token. And so while U

57:08may statistically be the most likely

57:10next token, maybe U has like a 98%

57:13confidence score or something, despite

57:15the fact that U is the most likely next

57:17token, we're not always going to pick

57:19you. What we're going to do is we're

57:20going to have some cutoff, which is sort

57:22of like this um top P. And then we're

57:25going to pick from one of these three or

57:26four options. And we're going to do so

57:28with a level of what's called

57:29stochasticity or randomness. That means

57:32that you can't actually predict what the

57:33large language model is going to do

57:35every time. Now, this isn't a bad thing.

57:37This is actually a good thing because

57:39think about it. If we could predict what

57:40every large language model was going to

57:42do, there would be no reason to have a

57:43large language model. If you just

57:44trained things and always outputed the

57:46exact same thing every time, there would

57:47be no way for the model to reason

57:49flexibly about things. It would

57:50essentially just be a giant series of

57:52dominoes that just, you know, knock over

57:54one to the other. Those are some really

57:55crappy looking dominoes to the other to

57:57the other. And then, you know, we'd be

57:58able to predict everything that's going

57:59on. Anyway, models um randomness and

58:02stochasticity is actually a big chunk of

58:04how they are capable of solving problems

58:05and reasoning for us. But what I'm

58:07trying to say is there's a level of

58:09randomness added to every step of the

58:10process. Right? So the first thing is

58:12they predict a distribution of options.

58:14What that means is there is some

58:15randomness. There is some statistical uh

58:18error here or or inaccuracy. Next, we

58:21can set the temperature and top P. These

58:22are settings that you'll find in

58:23parameters for most large language

58:25models nowadays. Those settings also

58:27introduce some randomness to the

58:28process. You now have um architectures

58:31like the mixture of experts architecture

58:33which is basically where they don't just

58:35have one large language model do this.

58:36They test this simultaneously across

58:38four or five large language models and

58:40then they pick the most commonly voted

58:42task. Believe it or not this introduces

58:44some additional variance. Then even at

58:46temperature zero tiny input variations

58:48can produce wildly different outputs

58:49because of randomness. Obviously there

58:51is um sort of like probabilities here at

58:53every step. Now in math these are

58:56basically called compound probabilities.

58:59And I don't mean to make this a math

59:00thing, but if you're working with AI,

59:02you might as well um learn at least a

59:04little bit of the math underneath it

59:05because it'll help you understand how

59:07all these things work. Essentially,

59:08these compound probabilities make it

59:10very unlikely that you'll be able to

59:12achieve the exact same outcome every

59:13time on the large language models own.

59:15And so what happens is you have these

59:16error rates that compound

59:18catastrophically. I'll give you a quick

59:20example. Let's say you have five steps

59:22in a process. You want the large

59:24language model to, I don't know, go out

59:26into your email inbox, pick the best

59:28email, then you want it to summarize

59:30that email, then you want to feed that

59:32summary into some other model, then you

59:34want that other model to take that

59:35summary and then combine it with a bunch

59:37of other summaries to give you a big

59:38digest of the day. So if you have five

59:41steps and each of them are 90%

59:44successful, the way that math works

59:46really is although every individual step

59:49may be 90% successful, if you math it

59:52out and actually multiply out 90%

59:54success for step one time 90% success

59:56for step two times 90% success for step

59:58three times 90% success for step four

1:00:01times 90% success for step five, you end

1:00:04up not with a 90% success rate across

1:00:07the entire process. you end up with a

1:00:0859% success rate across the entire

1:00:10process. Essentially what occurs is

1:00:12although the first step might be 90%.

1:00:15The second step when multiply makes it

1:00:17081 and then you have 64 or 74 or 63 and

1:00:21so on and so forth until eventually your

1:00:23actual total error rate is significantly

1:00:25higher. Your success rate on the other

1:00:27hand is significantly lower. And so when

1:00:29you add more and more steps to this

1:00:31process, you know, if you get to 10,

1:00:32it's 35% success rate. If you're at 20,

1:00:34it's 12% success rate. This applies even

1:00:37if models are 95% successful at specific

1:00:39tasks. What ends up happening is

1:00:41basically at every step of the task. A

1:00:44good way to consider it is the total

1:00:47range and outcomes gets bigger and

1:00:49bigger and bigger and bigger. There are

1:00:51super successful outcomes, sort of quasy

1:00:53successful outcomes. They're not

1:00:55successful outcomes and they're like

1:00:56catastrophic outcomes, right? And this

1:00:58range in business is nowhere near tight

1:01:02enough for most companies to trust

1:01:03systems like this. Now, because most

1:01:05business workflows are multi-step and

1:01:07because people have typically tried

1:01:09doing things like this with dumber,

1:01:10simpler models with no frameworks, you

1:01:12know, most raw LLMs are actually just

1:01:14not usable in business, aside from copy

1:01:16paste outputs, which is why people tend

1:01:17to do that. Just as an aside, imagine if

1:01:20you were a business that made $100,000 a

1:01:22month and you sent a wrong invoice 5% of

1:01:24the time. What sort of impact do you

1:01:26think you that would have to your

1:01:27business? Do you think that would have a

1:01:285% impact to your business? No, that

1:01:30would have like a 95% impact on your

1:01:32business. If I'm one of your clients and

1:01:33you send me the wrong invoice even one

1:01:35out of 20 times, I don't think I'm going

1:01:37to work with you the 21st time. So, the

1:01:39root cause here is we're asking

1:01:40probabilistic systems to do

1:01:42deterministic work. Probabilistic is

1:01:44that big sort of uninterpretable

1:01:47thought process that cloud that I showed

1:01:49you guys earlier. Whereas deterministic

1:01:51is what businesses use where you have

1:01:53one step going into the second step

1:01:55going into the third step going into the

1:01:56fourth step and so on and so on and so

1:01:58on and so forth. This over here is what

1:02:01business is and the best businesses, you

1:02:04know, productize and standardize

1:02:05everything. And then this over here um

1:02:08operates in the realm of probabilities

1:02:10which ultimately we can't use. What is

1:02:12the solution here? Well, it's not

1:02:13necessarily just making LLM smarter.

1:02:15Although keep in mind, the smarter the

1:02:17models get typically the less error and

1:02:18variance they do have. That's great. But

1:02:21the actual solution is we don't have to

1:02:22wait for model intelligence to get smart

1:02:24in an unspecified amount of time. We

1:02:26just build a framework around those

1:02:29models that turns these really rickety

1:02:31outputs into something that we could

1:02:33still use anyway despite the fact that

1:02:35there's variability in the process. We

1:02:38give them defined nodes and steps

1:02:40between each important thing that we

1:02:43want. And in that way, because we're

1:02:45shortening the total gap, models are

1:02:47capable of performing economically

1:02:48valuable work. So what we're going to do

1:02:50is wrap this super galaxy brain

1:02:52intelligence in a framework. And this

1:02:55framework is going to allow us to

1:02:57control it for beneficial purposes for

1:02:59ultimately business ends. Okay. So how

1:03:01do you actually do that? Well, this is

1:03:02now where you get into DO or the

1:03:04directive orchestration and execution

1:03:06framework. What we do is we separate

1:03:09concerns. Directives up at the very top

1:03:11provide very clear unambiguous

1:03:14instructions to the system. These are

1:03:16documents which if you guys remember

1:03:18were sort of the first rung on that

1:03:20knowledge ladder. Orchestration, if you

1:03:22think about the PTMRO loop, is where the

1:03:24large language model does its thing. It

1:03:27chooses what to do and in what order.

1:03:30And then execution scripts are the

1:03:32actual heavy lifting. And we don't do

1:03:34that with the model itself. What we do

1:03:37that are with little snippets of code

1:03:39that the model has built, then test, and

1:03:41then retested over and over and over

1:03:43again. Okay? I typically do this in

1:03:46Python right now, but I want you guys to

1:03:48know you can do this with whatever

1:03:50programming language you want. The

1:03:51models tend to be pretty good at I want

1:03:53to say most of them equally. The reason

1:03:55why this works so well is because of

1:03:56this concept of separation of concerns.

1:03:59Essentially, anything that is

1:04:00deterministic aka something that like a

1:04:02business would use. So maybe an API

1:04:04call, some sort of data transformation,

1:04:06some sort of file ops actually go into

1:04:09code. Code is always the same every

1:04:11single time. If you give it input A,

1:04:13it'll always give you output B. There's

1:04:15never any variability unless you

1:04:17specifically program that in. So, it's

1:04:19really, really interpretable. It's very,

1:04:20very clear how it works. And you never

1:04:22really need to wonder, hm, is that doing

1:04:24what I wanted it to do? Because it's

1:04:26only going to do what you told it to do.

1:04:28And then what we do is we leverage the

1:04:30really flexible, cool parts of AI to

1:04:32make judgments, to make routing

1:04:34decisions, and so on and so forth. Code

1:04:37is really reliable. It's also super fast

1:04:39and precise. LLMs are flexible,

1:04:41adaptive, and then also handle ambiguity

1:04:43really well. So, what we're doing is

1:04:45we're combining the best of both parts.

1:04:47We combine AI's incredible ability to

1:04:49route and be flexible and so on and so

1:04:52forth with deterministic code's

1:04:54extraordinarily ability to run really

1:04:57quickly, really precisely, and really,

1:04:59really repeatably. When you do this, you

1:05:01get the best of both worlds, and you can

1:05:02make a ton of money with it. That's how

1:05:04Agentic workflows work in a nutshell.

1:05:05What's interesting is you probably would

1:05:07not have understood any of this had you

1:05:08not watched the last hour to hour and a

1:05:10half of content all about the basis and

1:05:12the foundations. Some other reasons LLMs

1:05:15are really really bad at basic

1:05:16operations. When I say basic operations,

1:05:18I mean math. Up until quite recently, um

1:05:21LLM couldn't even count the number of

1:05:22letters in a word. That's something that

1:05:24you could build a Python script to do in

1:05:25like 0.1 seconds. You know, if you have

1:05:27a big list of numbers or something, you

1:05:29use LLM to sort those numbers. It's kind

1:05:31of like hiring a PhD intelligence to

1:05:33count some inventory. It's just not the

1:05:35best cost basis on your end. You're

1:05:36going to spend way too much money and

1:05:38get way too little of a result. Hence

1:05:39why we pushed the deterministic tasks to

1:05:42scripts and then reserve the LLM

1:05:43processing with the tokens for actual

1:05:45thinking. Also makes everything cheaper.

1:05:47Just for the purposes of demonstration,

1:05:49if I gave an LLM a really simple task

1:05:51and I said, "Hey, I have all of these um

1:05:54letters, okay, and they're all arranged,

1:05:57you know, in this list." And let's say

1:05:59this list hypothetically isn't just, you

1:06:01know, six letters long. It's like a 100

1:06:04thousand or 10,000 items long or

1:06:06something. It's just like really really

1:06:07long. Okay, so just pretend that I put

1:06:08this thing together and I give it to an

1:06:10LM. If I had the large language model

1:06:12sort this thing, it would have to run

1:06:14billions upon billions upon billions of

1:06:17mathematical operations to sort this

1:06:18list. If I gave this to a Python script,

1:06:22it could literally do this entire thing

1:06:24in one function call. I could probably

1:06:26do it in like 5 seconds on my own, not

1:06:28even with a large language model. And it

1:06:30would take milliseconds. If you look at

1:06:32the actual mathematical time and then

1:06:34the resource usage when you use uh

1:06:35deterministic scripts to do things like

1:06:37this, these mathematical simple

1:06:38operations like sort a big list, you

1:06:40could do it 10,000 to 100,000 times

1:06:42faster with deterministic code. And then

1:06:45it's also for the most part free because

1:06:47it's operating on your CPU or

1:06:49extraordinarily low cost cuz it's

1:06:50operating on some cloud CPU or GPU um

1:06:52that's very very uh affordable. This

1:06:55gets more and more and more difficult

1:06:56the more you do. Instead of having the

1:06:58large language model do math for us,

1:07:00what we do is we build a calculator tool

1:07:02and then we say, "Hey, can you call the

1:07:03calculator tool to do the math for us?"

1:07:05In this way, obviously, we're maximizing

1:07:07the best of all possible worlds. So now

1:07:09I want to show you the difference

1:07:10between using a large language model's

1:07:12native intelligence to do something that

1:07:14I think most would consider very simple,

1:07:16which is just sorting a list, and then

1:07:18using a Python script to do it instead.

1:07:20And I'm showing you this because there

1:07:22are so many advantages to using

1:07:23procedural deterministic tools like

1:07:25Python scripts. It's hard for me to know

1:07:27where to begin, but I just wanted to

1:07:28give this to you guys sort of as a

1:07:29representative example. So, what I've

1:07:31done up here is I've just had AI or an

1:07:33agent assist me with the creation of a

1:07:35brief demo list that I'm going to sort.

1:07:37The first thing I'm going to do is I'm

1:07:38going to tell it to sort the list on its

1:07:40own. Sort the list using only your

1:07:42native LLM intelligence. Do not make use

1:07:44of any tools. Time yourself and at the

1:07:47end, let me know how long it took.

1:07:50What I'm going to do now is let it run.

1:07:53And you'll see that when its native LLM

1:07:55intelligence does the sorting, it takes

1:07:57significantly longer in order to do so.

1:07:59We can see the time that it's taking by

1:08:01expanding this reasoning tab.

1:08:04Scroll all the way down here. You can

1:08:06see it's actually manually outputting

1:08:07every token. Here we go. And now it's

1:08:10actually gone through and sorted the

1:08:11list alphabetically by name. Okay.

1:08:13Anyway, it told us it didn't have its

1:08:14own internal clock or whatever, but

1:08:16realistically, as you guys could see and

1:08:18probably timestamped the video, this

1:08:19took what, 30 seconds or something like

1:08:20that from start to finish. Now, I want

1:08:22you to see how quickly it is when we

1:08:24just run a script to do it instead. Now,

1:08:26run the script.

1:08:30So, what it's going to do is instead

1:08:32it's just going to call said script,

1:08:34then it'll immediately sort this with

1:08:36significantly higher levels of accuracy

1:08:37on the right hand side. Now, I should

1:08:39note that the amount of time it took me

1:08:41to call the large language model and

1:08:42actually have it do the thing, that's a

1:08:44bunch of latency here that we're not

1:08:45actually taking into account.

1:08:47Realistically, this took 53

1:08:48milliseconds. The LLM, I mean, it's

1:08:50saying 3 to 5 seconds, but as you can

1:08:51tell, it doesn't really understand its

1:08:52own internal processing. So, it's closer

1:08:54to, you know, 15 to 30. That is um

1:08:56several hundred times faster. And not

1:08:58only is it several hundred times faster,

1:09:00a point that I'm going to make

1:09:01repeatedly throughout this course is

1:09:02also several hundred times freer because

1:09:04running a Python script to sort of list

1:09:06on your own CPU or even on cloud CPU

1:09:09when we get into uh posting web hooks

1:09:11and actually hosting these things on

1:09:12servers that aren't ours is like is

1:09:15essentially free. I mean it's it's

1:09:16occurring in the space of I don't know a

1:09:18neuron in your brain firing. This

1:09:19thing's doing a whole whole buttload of

1:09:21work. And you can see even down here it

1:09:23said this is the core argument for

1:09:24pushing deterministic work into tools.

1:09:26The LLM handles decision-making whereas

1:09:27the script handles execution. That's a

1:09:29major part of how we are going to be

1:09:31talking about how to use these and build

1:09:32these agentic workflows later on. So in

1:09:34a nutshell, my whole point is reserve

1:09:36your large language model calls for

1:09:37judgment. Let code handle the rest. By

1:09:40doing so, things will be significantly

1:09:42faster, things will be significantly

1:09:43more reliable and things will also be

1:09:45significantly cheaper. This is where the

1:09:47DO directive orchestration execution

1:09:49framework comes into play and it's how

1:09:51we're going to be building out the rest

1:09:52of the workflows in this course. Let's

1:09:54talk a little bit more about how to

1:09:56actually do this. Now, okay, so

1:09:57unsurprisingly, right now everything to

1:10:00do with the Gentic Workflows happens in

1:10:01what's called an IDE. If you guys are

1:10:04unfamiliar with IDE, that stands for

1:10:06integrated development environment. Now,

1:10:09idees look like this, and you've seen

1:10:12them already multiple times throughout

1:10:14this course. What they are is they are

1:10:16basically programming environments. Now,

1:10:20agentic workflows are not idees. To be

1:10:24clear here, this is just a way that

1:10:25we're communicating with them. If you

1:10:27guys remember way back in the beginning

1:10:28of this course, I talked about how chats

1:10:31were sort of like an interface and then

1:10:33agents were like things that lived

1:10:35inside of the interface almost the way

1:10:36that a crustation has shells and it can

1:10:38change shells at will. Well, right now,

1:10:41because programmers usually build stuff

1:10:43and because agentic workflows are

1:10:45composed of the same thing that

1:10:46programmers used to build, we just

1:10:48happen to do them in an IDE. But I want

1:10:50you to know that this is most likely to

1:10:52change. Now, I don't like IDEIDes

1:10:54because they just are really overly

1:10:55technical for a lot of newbies, people

1:10:57that don't understand this stuff, and

1:10:58they look at it and they look at all the

1:11:00lines on the page and all the different

1:11:01partitions and sections and then they

1:11:02go, "Holy crap, Nick. This is way too

1:11:04complicated. I'm not a technical person.

1:11:05I don't want to deal with it." But what

1:11:07I want to do in this course is I want to

1:11:09avail you of the notion that you have to

1:11:10be technical in order to understand

1:11:11what's going on. What this is is this is

1:11:13just the same thing as like a bunch of

1:11:15instrumentation panels on a car or

1:11:17something. You know, the very first time

1:11:18you step into a car, you don't know how

1:11:19the odometer works. You don't have any

1:11:21idea what the gear shift is, how the

1:11:23radio works, and all that stuff. This is

1:11:24the exact same thing. I'm currently

1:11:26taking my pilot's license right now, and

1:11:27let me tell you, the damn

1:11:29instrumentation panels on even the

1:11:30oldest and and cheapest of aircraft are

1:11:33sort of the way that I imagine IDs are

1:11:35to people that have never touched these

1:11:36things. So I entirely empathize with you

1:11:38and I'm going to walk you through it all

1:11:39in a moment. So as mentioned IDE stands

1:11:42for integrated development environment.

1:11:45I think of it as basically Microsoft

1:11:47Word just for code instead of you know

1:11:49natural text documents. They're composed

1:11:52of workspaces and this is the same

1:11:54language that basically any IDE will use

1:11:56where you basically just write organize

1:11:58run and then manage everything in one

1:11:59place. And it's important for me to note

1:12:01like how this works in a historical

1:12:02basis cuz otherwise you'll be like why

1:12:04the hell did we choose this? Well, the

1:12:06reason why is because back in the day,

1:12:07we actually used to have like five or

1:12:08six different tools. Uh, programmers

1:12:10would use tool number one to like write

1:12:12their code. Then they'd use tool number

1:12:15two to test their code. Then they jump

1:12:17over into tool number three to, I don't

1:12:19know, run their code, tool number four

1:12:21to host their code, tool number five to

1:12:24commit their code into a a repository so

1:12:27they could save it, and tool number six

1:12:29to do something else. And so there was

1:12:31just so much switching going on, right?

1:12:32We had to jump from tool number one to

1:12:33tool number two, whatever. And then

1:12:35somebody was just like, "Wait a second.

1:12:36Why don't we just combine all of these

1:12:37into one unified tool? Sure, the

1:12:39interface will probably be an absolute

1:12:41cluster, but you know, this is more than

1:12:43enough and it'll probably simplify and

1:12:44and alleviate some of the context

1:12:46switching." And that's basically what

1:12:47happened here. We basically just stuck

1:12:49them all into this one tool. And this

1:12:50tool is really like 20 or 30 tools

1:12:52simultaneously, which is why it looks so

1:12:54complicated. Now, over the course of

1:12:55just the last year or so, ids have

1:12:57gotten way smarter. And I mean smarter

1:12:59here as in like AI. So, in the last

1:13:02year, basically every IDE has added some

1:13:05form of AI chat capability. Old school

1:13:08ones like VS Code, and I'm going to

1:13:09cover what all these are in a minute,

1:13:11added built-in AI assistance quite

1:13:13recently. And then newer tools like

1:13:14anti-gravity, big one that Google just

1:13:16released, are now less like coding

1:13:18workspace, and they've just eliminated

1:13:20and streamlined most of the UX. So, it's

1:13:22almost all just like AI based agent

1:13:23stuff. Basically, the line between

1:13:25writing code and then just directing AI

1:13:27to do it all for you through natural

1:13:29language is blurring really quickly. And

1:13:30that's um one of the motivations behind

1:13:32our course actually. So this over here

1:13:34is VS Codes logo. This over here is um

1:13:37anti-gravities. And this over here is

1:13:39cursor. These are three relatively

1:13:41popular tools that I'm going to touch on

1:13:42in a little bit more detail. And then

1:13:44I'm actually going to walk through VS

1:13:45Code and anti-gravity just so you guys

1:13:47could see how all this stuff really

1:13:48plays out. In a nutshell, if you guys

1:13:49are going to be comfortable with agents,

1:13:51you need to be comfortable in an IDE.

1:13:53That's just the whole goal of today's

1:13:54module. So three areas of your IDE.

1:13:58There's a file explorer on the left.

1:13:59There's an editor panel in the center

1:14:01and then there's an agent chat panel on

1:14:03the right. Let's cover all of them in

1:14:04detail. On the lefth hand side, we have

1:14:07the file explorer. The file explorer

1:14:09almost always looks something like this.

1:14:11All this is is it's just another way

1:14:13that you guys can explore files. Just

1:14:15like on a Mac or a PC, you have the

1:14:17native file explorer. Here, your files

1:14:19are just arranged vertically as follows.

1:14:22This little tab just means that this is

1:14:24a folder. And if you click on one of

1:14:25these, obviously, this will open and

1:14:27expand. and then you'll be able to see

1:14:28all the files within. So just as like a

1:14:30sanity test, this um first kind of line

1:14:34here, this first folder is period cla

1:14:37and there are a bunch of other files

1:14:38inside of period claude. Same thing

1:14:40here. Period dev container period

1:14:43prompts period tmp period venv. You

1:14:47might be wondering, Nick, what the hell

1:14:48do any of these things mean? I'll be

1:14:49honest, I have AI do most of that. I

1:14:51don't even know, nor do I really care.

1:14:52The whole job of coding is not the point

1:14:54of gentic workflow building. All I'm

1:14:57doing is I'm just giving highle

1:14:58instructions and I have the AI deal with

1:14:59the how. Next up, we have a directives

1:15:02folder as you guys see here, an

1:15:03execution folder as we guys see here. Uh

1:15:06I also have a folder called for_youtube

1:15:08in my workspace. This is where I store

1:15:10things like this course node modules

1:15:13prompts trigger, right? What you'll

1:15:14notice is eventually we run out of

1:15:16folders, these little things with the

1:15:17tabs, and then everything else is just a

1:15:18file. So I have this file here, this

1:15:20file here, this file here. We we got a

1:15:22ton of files in the workspace. But

1:15:24hopefully now you guys have like looked

1:15:25at it and squinted hard enough at it

1:15:27that you guys at least understand that

1:15:28there's nothing magical going on here.

1:15:29This is just a file explorer. So just

1:15:32like with any other file explorer, you

1:15:33can create files, you can rename files,

1:15:35you can delete files, and you can

1:15:36organize everything you want from here.

1:15:38For Aentic work, at least in our case,

1:15:40the DO framework. This is also where the

1:15:43directives and executions folders live.

1:15:45As we saw earlier, I had the directives

1:15:47folder here and then the execution

1:15:48folder. I'm going to dive into those and

1:15:49actually show you what these look like

1:15:50in a moment. And really just the way to

1:15:52think about this whole thing is as a

1:15:56filing cabinet. Okay, that does not look

1:15:59like an F, but we're going to roll with

1:16:00it regardless. This is just your filing

1:16:02cabinet for your agent. And so that is

1:16:03how I want you to think about this

1:16:05moving forward. In the middle of the

1:16:06page, you have the editor panel. Now,

1:16:08this is typically in the center,

1:16:10although some idees will vary. That's

1:16:12okay. I'll cover two instances today.

1:16:14When you click on a file, this is where

1:16:16they open. And so for instance, as we

1:16:18see here in this middle panel, I have a

1:16:19file open called capitalized agents.mmd.

1:16:23Now we get into system prompts and how

1:16:25to actually control these u models

1:16:27through long-term context later on. But

1:16:29this is basically just like a file that

1:16:31you will add to any workspace and it'll

1:16:33just be injected at the very top of your

1:16:35agent. So the agent will just always see

1:16:37this in its context 24/7. And in my

1:16:40case, what I do is I just give it some

1:16:41highle instructions describing my

1:16:43framework. Hey, you operate within a

1:16:45three-layer architecture that separates

1:16:46concerns to maximize reliability because

1:16:49of the same things that I just taught to

1:16:50you. LLMs are probabilistic. Most

1:16:52business logic deterministic so on and

1:16:54so on and so forth. Okay? So, we'll

1:16:56cover this file later, but for now, I

1:16:57just want you to know that you can

1:16:58actually open multiple files and tabs

1:16:59just like a browser. You guys see here

1:17:01how this is sort of like a tab. Well,

1:17:03you can actually have multiple other

1:17:04ones open, too. I could have, you know,

1:17:05another file here, and then another file

1:17:07here, and another file here. You'll

1:17:09notice that some of these letters are

1:17:10different colors. You see how this one's

1:17:11blue and then this uh little um you know

1:17:14right arrow is green and then this text

1:17:16is white and then this is uh sort of

1:17:18orangey. Well, the reason why is just

1:17:20because um this this is a natural

1:17:22language file. This is markdown it's

1:17:24called which is a specific format. But

1:17:26like when you're dealing with code like

1:17:27Python and JavaScript and Node and so on

1:17:30and so forth, there's just so many

1:17:31different types of text that coloring it

1:17:33just makes it a little bit easier on the

1:17:34eyes and you can just tell what's going

1:17:36on faster. So in the case of markdown,

1:17:38which is the format that my natural

1:17:40language or almost plain text files are

1:17:41in, um if something is in blue, it's a

1:17:44header. So you know that this is like a

1:17:45header of some kind, right? Same thing

1:17:47over here, right? This is a header or

1:17:48it's like bolded, right? So that's what

1:17:50that is. If something is in orange, you

1:17:52know it's written in like code format.

1:17:53So anytime you write something in code

1:17:55format, it's done with these little back

1:17:57texts. Something is in white, odds are

1:17:58it's just like normal text. Something's

1:18:00in green, it's like a comment or

1:18:01something like that, right? This depends

1:18:03on the format. Typically, we only use

1:18:05two or three formats in Aentic Workflow.

1:18:07So, you're just going to figure this out

1:18:08really quick. Nor does it really matter

1:18:09to be honest because you you never

1:18:11actually read files. And that actually

1:18:12takes me to a great point. Um, you can

1:18:14look at files in the editor panel, but

1:18:16you'd almost never actually manually

1:18:17edit them. My rule of thumb is if I'm

1:18:20manually editing a file, I am doing

1:18:22something horrifically wrong because

1:18:24there's no real reason why I should be

1:18:25manually editing a file. I just

1:18:27communicate with my agent and then it

1:18:28does it for me. Even if I want to change

1:18:30a specific file, I won't go into that

1:18:32file. I'll just say hey change specific

1:18:34file to do this and then typically I'll

1:18:36just give it a oneline description of

1:18:38what I want it to do and it'll go

1:18:39through and it'll do it in the most

1:18:40efficient way. In this way I'm almost

1:18:42like the CEO of my own company. I mean I

1:18:44am the CEO of my own company but I am

1:18:47like the CEO of my own agent company. I

1:18:49just give very highle instructions and

1:18:51then it's the agent that interprets

1:18:52those highle instructions and does

1:18:53things. So that's two out of the three

1:18:55sections. The third is the agent chat

1:18:57panel that exists all the way on the

1:18:59right. So the agent chat panel is

1:19:00hopefully very familiar to you guys.

1:19:02Same sort of thing as just any chat over

1:19:04the last four or five years. In this

1:19:06case, I just said, "Hey, what's up?" It

1:19:07then read through agents.mmd. As I told

1:19:09you, it always reads through this at the

1:19:11very beginning of every run. And then it

1:19:12says, "Hey, not much. Just ready to

1:19:14help. What are you working on?" So, this

1:19:15is your primary interface. This is

1:19:17really where you're going to live. And

1:19:19uh it's such a primary interface that

1:19:20the modern idees like anti-gravity and

1:19:22stuff have basically done away with

1:19:24everything else except for this. And you

1:19:25just talk to this all day. So, you'll

1:19:27type your instructions here. Agent will

1:19:29respond. You can even see the thinking

1:19:31tab over here with the reasoning

1:19:32processes is deciding what actions to

1:19:34take. That's really cool for

1:19:35interpretability reasons. And it's also

1:19:37just one of my favorite things to watch

1:19:38because you're seeing the AI's internal

1:19:40monologue. It's also good and and useful

1:19:42when you're building aic workflows,

1:19:44which obviously we're going to cover uh

1:19:45quite shortly so that you could stop it

1:19:47if it makes some mistake. Um you could

1:19:50see where maybe an error is, do your

1:19:51debugging and so on and so forth.

1:19:53Finally, just an obligatory section on

1:19:55code. I know code is really intimidating

1:19:57for a lot of people. I want you to know

1:19:59that all scripts are is they're just

1:20:01text written in a hyperspecific way.

1:20:04This over here is what's called Python.

1:20:07Do I know what's going on over here? I

1:20:09mean, yeah. I've done some coding in

1:20:10Python, so I can look at this. I can

1:20:12kind of interpret it, but I I I can't do

1:20:14so very quickly, and I don't know what's

1:20:16going on for the most part. You don't

1:20:18actually need to have any clue what's

1:20:20going on in the code these days in order

1:20:21to do really powerful, effective things

1:20:23with them because, as I mentioned

1:20:24earlier, AI is just a way better coder

1:20:26than you. So, if you find yourself

1:20:28opening coding scripts and stuff, you're

1:20:30probably doing something wrong. I never

1:20:31actually have a page open like this

1:20:33because it just means no difference to

1:20:34me. Now, if you do find yourself opening

1:20:37this for whatever reason, I want you to

1:20:38know that a Python script or whatever

1:20:40language you're using, Python's just one

1:20:41of the many. It's just a set of

1:20:43instructions for the computer to follow.

1:20:44It's the same sort of thing as like the

1:20:46the the bullet points that I was showing

1:20:48you guys at the beginning of the course

1:20:49where I was describing an instantly auto

1:20:51reply bot. This is just a set of

1:20:53instructions written in a way that this

1:20:54computer understands, but it's literally

1:20:56just text sitting in a file. It doesn't

1:20:57do anything on its own. What you have to

1:20:59do in order to turn this into some sort

1:21:01of function, turn this into some sort of

1:21:03execution script, is you have to run it.

1:21:04And that just means telling the computer

1:21:06to run the instructions. And typically

1:21:08the way you do this is you do this

1:21:09through the terminal yourself. You'd

1:21:11find the file, you'd see it's called

1:21:12Python script. py. Then you'd actually

1:21:15go into the terminal and very

1:21:16intimidatingly, you know, if you even

1:21:18script one character, it's not going to

1:21:19work. You actually have to type all that

1:21:20yourself. Well, guess what? you no

1:21:22longer have to do that. The agent just

1:21:24does all the coding for you and then it

1:21:25also runs the code for you. That's what

1:21:27makes it such a powerful um orchestrator

1:21:30and that's why I live entirely in the

1:21:32editor. Agents just run all the code. I

1:21:35just say, "Hey, run my Upwork scraper."

1:21:37Do I have to know the format to to

1:21:38execute it? No, I don't. What I do is I

1:21:41just say, "Do the thing I want." It'll

1:21:43then do some thinking. It'll find the

1:21:45specific file that I'm referencing and

1:21:46then it'll go and it'll run it. And so

1:21:48now this is actually running. It handles

1:21:50the entire execution loop autonomously.

1:21:52That's the whole point of agentic

1:21:53workflows. So don't worry about being

1:21:55hyper precise. If you spend too much

1:21:57time being hyper precise, you're kind of

1:21:58wasting it because models, as I

1:22:00mentioned, are just millions of times

1:22:01faster than us. They think just

1:22:02extraordinarily quickly. This is really

1:22:04just the domain of the model.

1:22:06Communicate with it almost like you'd be

1:22:07communicating with an employee or staff

1:22:09member. Obviously, you wouldn't say,

1:22:10"Hey, Pete, run the Upwork scraper. Give

1:22:12me the results. Uh, post it to Slack and

1:22:14then give me the Google sheet URL. Hey,

1:22:16could you send Sandy an email about X,

1:22:18Y, and Z? Use the email template. Just

1:22:20speak to it like you'd speak with an

1:22:22employee. Don't speak with it like you'd

1:22:23speak with a programmer, and you're

1:22:24going to do a lot better. When you do

1:22:26this, your IDE becomes essentially a

1:22:28visual chatbot where you can just watch

1:22:30the agent work 24/7. And that's where

1:22:32things get really cool and really

1:22:33powerful. So, back in the day when we

1:22:36didn't have agents, we had to create a

1:22:37lot of this stuff manually. What I have

1:22:39open here on the right is the terminal.

1:22:42And the terminal is essentially the

1:22:44command line interface way that you

1:22:47would communicate with your computer in

1:22:48order to get valuable knowledge work

1:22:50done. Usually programming work. And so

1:22:53before you know I couldn't just say hey

1:22:55write me a script that does XYZ. Why? It

1:22:59would say command not found. This only

1:23:02works in the context of specific

1:23:04commands. You know instead I would have

1:23:06to use Python 3 for instance. I'd