Latest / In The Loop / How to build your own AI personal operating system & second brain

Transcript

How to build your own AI personal operating system & second brain · In The Loop

0:00
It may be the fact that no one's listening to this podcast, and
0:03
it's probably a bit of a bubble, but it feels like right now
0:07
there's another zeitgeist in the world of AI emerging.
0:11
And it's hard to give AI systems true 24/7 contexts of everything
0:15
in your life, your projects, and to create what you could
0:18
describe as a true memory system or a personal AI operating
0:22
system for your clod. And this second brain isn't
0:25
really for you, it's for your agents.
0:27
Most of the content online about productivity and planning and
0:31
organization is optimising for human readability with good ways
0:37
for us to take notes in different systems.
0:39
But the world is no longer for us and our second brain, it's
0:43
for agents having a second brain.
0:46
By the end of this episode, you'll have your own personal AI
0:49
operating system by building a second brain for your agents, An
0:53
exact file structure to copy the different sections that you're
0:56
going to create to create a the different sections that you're
0:59
going to build to give fantastic scalable structure for your
1:04
agent to do more work for you. And a daily routine that you can
1:08
eventually automate, which will keep this continually updated.
1:12
This in the loop with Jack Horton.
1:14
I hope you enjoyed the show. So let's start where this wave
1:32
has come from, this like drive to build AI operating systems.
1:37
Now it hit mainstream popularity recently because of Andre
1:42
Capathi posting online about his MLM knowledge kind of wiki in
1:46
early April. And it's basically how he
1:48
organized his own notes so AI can read them.
1:51
And he sparked an explosion of different people and thought
1:54
leaders and influencers sharing how essentially they create
1:57
their own note system but for agents to read from.
2:01
But in reality, this has come from coding, as I said a good
2:05
number of episodes ago, probably all the way back to that called
2:08
Co work episode. The huge revolution that hit
2:12
coding is just going to hit the entire rest of the world over
2:16
the next 12 to 18 months. And a big part of that has been
2:19
your structure of information that you feed to an agent.
2:23
Now I've started to touch on this.
2:24
I touched on the Co work episode, I touched it on the
2:27
skills episode, I touched it on the episode discussing automated
2:31
scheduled tasks and and other new features they've just
2:34
released. And essentially this is a set of
2:37
folders on your computer which are MD files, So plain text
2:41
files arranged in a particular order.
2:44
So whenever an agent you're working with starts its session,
2:49
it can access it and then it will follow that folder
2:51
structure to only get the relevant information it needs at
2:54
that exact moment. Now inside that folder going to
2:58
leave four kinds of thing. And once you see them as four
3:01
separate jobs, the architecture of this folder structure makes
3:05
sense. And just before I get into this,
3:09
if you remember, for those that have been using Co work now, for
3:12
those that are in, you know, in IDE and to do coding, you're
3:16
going to be very familiar with this.
3:18
But essentially local files on your desktop or your laptop is
3:22
the folder of this type of system.
3:24
So a folder structure. And essentially you're going to
3:27
have different folders within, or should I say subfolders
3:30
within a master folder. And for some of you that might
3:32
go well, that doesn't seem that special, but it's exactly how
3:35
the most efficient organizations in the world are running the
3:38
system. It's how we run a lot of our
3:41
teams. Now there's a caveat to this,
3:44
which I think this is a moment in time and this is something
3:46
that you should use, but I mean mindset, this is the product
3:49
that we're currently building to help with product development.
3:51
So engineering design, product management, which is a system to
3:56
take us away from just relying on local files just, and it's an
3:59
infinitely more scalable, but for a personal operating system,
4:03
it's really, really powerful. So the first folder, or let's
4:26
say job, is identity. So that's the file that tells
4:30
the agent who you are, how you work, what you never do.
4:34
You know the bit that just shouldn't really ever change.
4:36
It might include your communication style, your
4:38
decision principles, maybe you know some of the rules that
4:41
you'd never break. The second is context.
4:44
So what's, what does the world look like today for you?
4:47
You know, what are the key projects that you're working on
4:49
over the next one, three, six months?
4:52
Who are the key people in that, in that world?
4:55
You know, who's your boss, who's your colleagues?
4:57
What do they like? What do they don't like?
4:59
They might also be commitments you've made and you refuse to
5:03
relegate them. And they could also include the
5:05
active projects in flight. The third is your skills.
5:09
So these are repeatable workflows.
5:11
You know, we've talked about skills a few weeks ago.
5:14
There are multi step processes about how you approach different
5:18
problems and situations and scenarios, whether it's a
5:20
script, an e-mail, a deal review, a weekly e-mail summary
5:25
to your boss, whatever it might be.
5:27
And the 4th is memory. So that's what happened, what
5:30
you decided, what open decisions there are still essentially it's
5:35
a session log from yesterday that the agent will pick up from
5:37
every single day. This part in particular is where
5:40
what we call Memex, our new product that it were releasing
5:43
at the moment, is essentially scaling because as you can
5:47
imagine, the amount of decisions getting logged to give your
5:50
agent a second brain is insane. So that's where we've had to
5:54
build our own internal tool to fix because we've got an entire
5:57
company trying to manage this type of system.
6:01
Anyway, to summarize those types of jobs you've got, essentially
6:05
identity is going to capture the unchangeable and then context
6:09
captures the things that are going to perish.
6:12
So you're going to update and change them every month, 3
6:14
weeks, 2 days, six months. Skills capture the things that
6:18
are very repeatable and memory captures the historical
6:22
conversations that you've been having.
6:24
So 4 jobs all sitting inside one parent folder structure that any
6:29
agent can read. Now the shape of that parent
6:33
folder, in case you're, you know, on a walk you're trying to
6:36
imagine this is, is roughly as follows.
6:39
At the top of that folder is what we call a master file.
6:44
So essentially by convention in core code that's called the claw
6:47
dot MD. But in other tools, the same
6:50
content goes as essentially a set of instructions or folder
6:53
instructions that essentially tells the agent how to
6:55
understand and navigate the folder structure.
6:59
That master file holds the identity layer plus pointers to
7:02
everything else. So essentially you're directing
7:04
the AI when and when not to use these sets of systems and
7:08
information. Alongside it sits A context
7:12
folder. So that will hold files are
7:13
active projects dot MD, recent decisions dot MD, stakeholders
7:18
dot MD, constraints dot MD, and then a skills folder.
7:25
And that skills folder will have the subfolder and it will have
7:28
all the skills inside it. So that could be your e-mail
7:31
skill, your shout at someone's skill, your apology skill, you
7:36
know, whatever it might be. Then finally you've got a memory
7:38
folder, which is essentially a big memory MD document with
7:42
topic specific files. So that will have a daily folder
7:45
with one log per session. So it might have today's date or
7:49
tomorrow's date. So then every sets of
7:52
conversations you have with different agents, you can update
7:54
that log. So essentially, there you go, 6
7:57
folders. You got one master file to tell
7:59
the agent how to use all of it. It's all just text.
8:03
And that's the architecture. And by creating that scalable
8:06
system, you don't ever have to speak to an agent as if it
8:10
doesn't understand what you're trying to achieve.
8:11
It just has all the context you need immediately.
8:14
And then when you try and choose the very best model and have
8:17
maximum reasoning mode on there, you're going to get the best
8:19
results. And because you're not trying to
8:22
give it too much context in one setting, you can also reduce the
8:25
context window and therefore have less token usage.
8:46
And now we're going to move on one step deeper.
8:49
Let's write the master file since you know that's the the
8:52
doorway the agent will step through when understanding the
8:56
rest of your personal operating system.
8:58
So Section 1 might be a company overview.
9:00
You know, two or three sentence about who you work for, what
9:02
they do, what stage of the business there are Section 2
9:05
will be current priorities. So top three or four things
9:08
you're trying to do this next quarter specific outcomes rather
9:12
than, you know, random, you know, themes, you know, maybe
9:15
hire two people by the end of March.
9:18
Section 3 is you know your voice and tone, how you communicate
9:21
the words you band, the style references you like to write
9:24
towards. For example, I have an entire
9:27
set of information on banned words.
9:30
I'll get some of them up. Corporate therapist book voices
9:33
banned. This is a powerful opportunity
9:35
to lean into our strengths. A meaningless conclusion.
9:39
AI loves meaningless conclusions at the end of a paragraph.
9:43
You know. Ultimately the goal of an
9:45
organization is to be more resilient and agile.
9:49
Pointless or the keynote punchline.
9:51
Voice the forced negation stating the obvious back all the
9:55
time over a flattery and excessive adverb.
10:00
So I've got an entire I mean, gosh, it's so big at this point,
10:04
right? Maybe 1200 Word document on all
10:06
the things I absolutely hate. Section 4 will be your key
10:09
relationship. So it might be people at work
10:10
could be people at home. So it might be, you know, my CEO
10:15
is called X. They care about why they respond
10:18
better to this and this type of and topic area or behaviour.
10:24
So just information that's relevant to the people you work
10:26
with and also their skills. Section 5 is standing decisions,
10:32
so things you've already agreed on and don't want the agent to
10:34
have to re question. And section 6 is things you
10:36
don't do, the constraints, maybe the things that you've got out
10:39
of scope you refuse to consider doing.
10:42
You know, I don't do X before 9:00 AM, whatever it might be.
10:47
And that's the template, that's the whole file should be about
10:51
150 lines roughly. And if something feels like I
10:54
want to add more words than 150 to 200 lines, you should
10:58
reference the skills. And we'll come on to this in a
11:00
minute. But you say use X skill under Y
11:02
situation, and that can then have many, many more texts or
11:06
lines of text. And 200 is the really important
11:09
number here because Anthropics actual documentation says that
11:13
any master file over 200 lines will essentially just be
11:18
ignored. So the agent will only read 199
11:22
or 200 lines of the 200 line and documents.
11:25
So if you made a 500 word one, it won't actually be useful, it
11:30
won't be used by the agent. So that's the system, that's the
11:50
master file to give your agents instructions.
11:53
And I'm going to go into two more things.
11:54
So it's going to be the skills folder and the structure.
11:56
I'm not going to spend too much time here because I actually
11:59
encourage you to go and use or listen to the skills episode.
12:03
And I'm also going to describe the daily routine you must
12:05
follow to make this entire system work.
12:08
So starting with the skills folder, essentially this whole
12:12
thing stops obviously being just static instructions for an
12:15
agent. And then it becomes like an
12:17
operating system when you essentially have lots of skills
12:21
and scheduled tasks working. So you know, every time you have
12:25
a workflow that you do more than two, three times, you should
12:28
turn it into a skill. And you're going to have a
12:31
folder that is going to have all of your skills inside it.
12:34
And the agent should just be able to structure it.
12:36
So if you've opened desktop Commander or if you're allowed
12:41
the agent to take control of your local files, just tell it
12:45
to organize the skills, put it inside the folder structure that
12:48
you created. Again, I would say there's tell
12:51
cords or tell whatever system that you're using to do it for
12:54
you. It could be discovery and
12:57
conversation prep and you could have a skill there that before
13:00
any call generate 5 hypothesis LED questions maybe to this
13:05
prospects industry and always frame questions as a hypothesis
13:10
to test, not a fact because we want them to confirm.
13:13
Could be as simple as that or something highly complex.
13:16
Some people have been quite ambitious.
13:18
They've got literally like 24/7 content engine runs going,
13:22
generating ideas, drafting scripts, writing SOP's, creating
13:25
slide decks, just doing so so much.
13:28
But that that's going to cost you an absolute fortune.
13:31
And the important thing is that once you build this architecture
13:34
that I'm describing, you can really start to turn it into an
13:39
operating system because identity tells the agent who's
13:42
running the workflow, Context tells it the current state of
13:45
the world, skills tell it how to actually run that specific task.
13:51
And as I'll come on to it in a minute, you'll have a daily log
13:54
system that will keep track of all major decisions that are
13:57
made. And all of this can be happening
13:59
on a scheduled routine. So every time the agent is doing
14:03
this task, you don't need to prompt it.
14:05
It is just taking all the information that you've already
14:07
built through this architecture. And this comes on to the final
14:10
part, which is that daily session log loop that I
14:14
mentioned right at the start. So before we end every single
14:17
session, we're now going to write a session log.
14:19
We're going to literally tell the agent write a session log.
14:23
It's going to cover what we worked on with the agent, and it
14:27
should only be about 3 bullet points Max.
14:29
You can turn this into a skill. So you can go slash daily log
14:32
and tell it where to store that information.
14:34
So store this in X place within the file structure I've created
14:38
and label it by the day of the week and the time we made it.
14:42
And it should, yeah, as I said, it should cover what we that
14:44
what you and the agent worked on, the decisions made with any
14:48
reasoning, any open questions that are going to be need to be
14:51
covered next time, any files that were touched and anything
14:54
in the memory MD that should be updated based on the session or
14:58
anything that needs to be changed to skills or anything
15:01
else as a result of that session.
15:03
So those were very highly structured because the agent can
15:05
then scan it and we'll just have that information immediately.
15:10
And you can get quite clever here.
15:11
You could run a scheduled task called weekly review where on a
15:14
Sunday, for example, where it reads all of the daily journals
15:18
or updates or logs, maps them against annual objectives, key
15:21
priorities, and essentially give a review of progress and things
15:26
that we need to make sure we do next week.
15:29
So you can do quite clever things with this as well.
15:31
So they help progress other initiatives you might be trying
15:33
to get through. And anytime you you find it
15:36
going wrong, tell it to update the master doc, tell it to
15:39
update something in the system to improve this.
15:41
So it's continually growing and improving.
15:44
So yeah, let's let's wrap up. So I guess my call to action to
15:48
everyone listening is go and get on this properly.
15:52
You know, set up a folder, dedicate an hour, I'll put it
15:55
inside a link in the Apple and Spotify podcast show notes so
16:01
you can get access to this. But go and create that
16:04
substructure or that folder structure with those subfolders.
16:08
It'll take you less than an hour and suddenly you'll start to be
16:12
able to create a true AI operating system.
16:14
And I bet if you do that, by the end of the week, the agent's
16:17
going to know more about you and your work.
16:19
And just save so much time of no, don't do it like this, do it
16:23
like that type conversations that that one hour will save you
16:27
many, many more hours. Anyway, thank you for listening
16:31
and I'll see you next time.