Episode 61

full
Published on:

27th Sep 2026

Building a Company Brain for AI - Jacob Dietle

Every time you explain your business to an AI from scratch, you’re repeating work. The opportunity with context engineering is to make your company’s expertise, processes, and past learning available whenever an agent needs them—so each new task builds on what you already know.

In this episode, I’m joined by Jacob Dietle—a consultant focused on context engineering and AI collaboration—to explore company brains, shared knowledge, and how to give agents the information they need to do useful work.

We discuss:

  • What context engineering means in practice
  • When to move beyond individual ChatGPT projects to shared company context
  • How existing knowledge bases fit into a company brain
  • Turning customer conversations into insights agents can reuse
  • Using skills, version control, and source evidence to manage context
  • How agents find information without loading everything at once
  • The challenges of keeping context useful across teams

Whether you’re building AI workflows for yourself or helping your company adopt agents, this conversation explores the decisions involved in organizing knowledge, choosing tools, and starting with practical use cases.

About Today's Guest

Jacob Dietle helps teams organize company knowledge and build systems for AI collaboration through Taste Systems.

His work combines context engineering, knowledge management, and team enablement, with a focus on making company expertise usable across people and agents. In this conversation, he shares his approach to working with seed and Series A companies on AI for go-to-market.

You can find him sharing his work on LinkedIn and his Substack, Speed to Insight.

Key Topics

  • [00:00] - Introduction and defining context engineering
  • [03:30] - How business context changes AI outputs
  • [05:15] - From individual AI projects to company brains
  • [09:20] - Where existing knowledge bases fit
  • [14:27] - Choosing where to start
  • [17:12] - Turning customer calls into grounded insights
  • [22:45] - Building useful skills without modeling the whole business
  • [25:25] - Version control and preserving organizational learning
  • [30:46] - Choosing tools and structures for your use case
  • [33:06] - Progressive disclosure and how agents retrieve context
  • [34:53] - File-based retrieval versus semantic search
  • [39:44] - Managing context across teams
  • [41:40] - Self-learning systems and human review
  • [43:26] - Connecting with Jacob

Resource Links

Learn More

Visit the RevOps FM Substack for our weekly newsletter:

Newsletter

Transcript
Justin:

I'm here today with Jacob Dedel.

2

:

Jacob, thanks so much for doing this.

3

:

And I was saying to you, uh, when we

chatted earlier, you know, you, uh, have

4

:

just been popping up in my LinkedIn feed

for the past, uh, probably the past few

5

:

years, and I really love how, um, you,

it feels like you take a very methodical,

6

:

very experimental approach to this topic,

uh, really trying to understand it from

7

:

first principles and figure it out,

8

:

so I'm really glad we can have this

time together and just kinda dig

9

:

into your knowledge in this area,

which is, uh, context engineering.

10

:

Jacob Dietle: Yep

11

:

Justin: I just wanna get everybody

onto the same place right now

12

:

around, like, what is this?

13

:

This term, you know, what do you

interpret this to actually mean?

14

:

Jacob Dietle: Yeah, I mean, well,

number one, thanks for having me.

15

:

I'm, uh, I'm excited to dive in.

16

:

I think the big thing is stepping back.

17

:

Like context mattered before

AI or anything else like that.

18

:

It's really like, does someone

have the context, right?

19

:

Do they know what's going on?

20

:

Do they know why it's happening?

21

:

Almost, right, the background information

of a certain problem or scenario

22

:

matters more, just as much, if not

more than the actual specific question.

23

:

And then context engineering, I

think of it as the explicit kind of

24

:

information architecture design of

doing that over and over and over again.

25

:

Um, so I can give you more spec-specific

examples, but I think kind of

26

:

reframing that and using stories

of like, you know, does Justin have

27

:

the context on this, is, is big.

28

:

And then turning that into like, almost

like a machine-readable explicit format.

29

:

'Cause we use our intuition

a lot for context, but AI

30

:

doesn't have intuition, right?

31

:

You can't assume that

it'll go figure it out.

32

:

So you have to give it, "Well, this

is how you would go figure it out."

33

:

Uh, a good example is like think

of if you had to drop somebody with

34

:

no context into your business, and

tell them to go solve a problem.

35

:

They'd probably fumble

around a lot, right?

36

:

That's even a very intelligent human

being with intuition to go figure

37

:

out, "Oh, I should probably go look

in the CRM or do this or do that."

38

:

AI has no intuition.

39

:

It has no way to like, kinda

like self-solve or help.

40

:

You have to give it explicit

machine-readable context

41

:

Justin: You know, it's funny that you

compare it to just like the human version

42

:

of context, 'cause I hadn't actually

even really thought about it that way

43

:

Jacob Dietle: Yeah.

44

:

Justin: explicitly.

45

:

But that makes complete sense, 'cause

an LLM, it's like stateless, right?

46

:

It's just waking up like out of a slumber

with all this brain power but no knowledge

47

:

of what's going on, only knows what you

48

:

Jacob Dietle: Exactly

49

:

Justin: How much of, how much of

the engineering part is actual

50

:

engineering or is that just

like a, term that we, put on it?

51

:

Like is there a, an engineering

component to context

52

:

Jacob Dietle: Yeah.

53

:

I mean, I, I treat it as

an engineering discipline.

54

:

Uh, I think of it as…

55

:

So there's a long story.

56

:

The long story of, like, computing is you

start with, like, one medium of, like,

57

:

punch cards, and people are like, "Man,

punch cards w- were really bottlenecked.

58

:

We're having to, like, manually arrange

these punch cards, these zero and ones.

59

:

It'd be really nice if we had a system

that sat on top of it, and I could like s-

60

:

you know, put into that system, uh, that

was worth 35 punch cards, like one line

61

:

or one line of code or whatever," right?

62

:

So the long li- long history of

computing is, like, we keep on

63

:

adding these new layers that, like,

you and I never write C, right?

64

:

We never write in C++ or all

these lower level languages.

65

:

now it's people aren't even

writing explicit like TypeScript

66

:

or Python or Rust or whatever.

67

:

They're writing in plain English.

68

:

But you still have to think through

these problems structurally and with an

69

:

engineering mindset -- and instead of it

being, you know, TypeScript service, it's

70

:

the plain English specification, right?

71

:

But you still have to think of

it as an engineering problem

72

:

Justin: to make it concrete, to

make it real for everybody, uh,

73

:

is there an example that you've

either encountered or can think of,

74

:

of like good context, bad context?

75

:

Or like what, what is the difference

that context actually makes like to

76

:

emphasize why this is so important?

77

:

Jacob Dietle: Yeah.

78

:

I think an easy one is like, let's

say you're taking a sales transcript

79

:

and you're just be like, "Hey,

let's pull out," um, a super,

80

:

super question is like, "All right.

81

:

Let's turn this into a, a next step

or scope of work, or what are the

82

:

sales objections in this thing?"

83

:

If you're going into like a, a base

ChatGPT or whatever language model

84

:

you're using, and it knows nothing

about your business, it's gonna give

85

:

you the most generic answer possible.

86

:

And really that's what this, the whole

context thing about is about, especially

87

:

in knowledge work like go-to-market,

it's so you're not starting from generic

88

:

and so having to re-explain yourself

over and over and over again to the AI.

89

:

'Cause let's say your business

has a very specific way of…

90

:

like every single business, right?

91

:

You have a very specific way of

processing, um, you know, doing

92

:

customer success or delivering a

service or anything else like that.

93

:

And the more you can like define the

explicit way you want things done,

94

:

just like if you were talking to a

human being of like, "This is how

95

:

we do scopes of work," or, "This

is how we do, um, you know, our

96

:

master service agreement," right?

97

:

That formatting is context.

98

:

That explicit way of how we do things

and why we do things is context.

99

:

And the-- that's then that gets into

a skill, and that's why people create

100

:

skills to make sure the language

model always knows or the agent always

101

:

knows, okay, um, these are our code,

you know, style guidelines, or this

102

:

is our content scout style guidelines

or whatever that end process is.

103

:

Think, think, thinking through that

process and like kind of breaking it

104

:

up into its atomic parts is, um, a

large portion of context and sharing

105

:

Justin: In a lot of ways, like,

feels familiar to me from, like, a, a

106

:

systems and an operations perspective,

107

:

Jacob Dietle: Exactly

108

:

Justin: lot of the thing that we're

concerned about is, like, maintainability

109

:

problem, it's a scalability problem,

it's a knowledge capture problem.

110

:

Jacob Dietle: Yep.

111

:

Justin: that most people start this…

112

:

I'm sure we've all done this.

113

:

Like you, all right, you create a

ChatGPT project or a Claude project,

114

:

and you, like, upload some stuff

there, and you're like: "Oh, no, this

115

:

is-- I can't share it very easily.

116

:

It's getting stale."

117

:

And maybe you, like, start building

out your local little universe.

118

:

But then at a certain point, you're like:

"I need this to scale across the company."

119

:

And this is where this idea of, like, I

think you call it a context OS, right?

120

:

You see on, on X, like, people talking

about company brains, and it's really

121

:

hard, I find, to, uh, differentiate,

like, there's something really real

122

:

here or no, this is just the latest sort

123

:

Jacob Dietle: The whole thing.

124

:

Justin: that

125

:

Jacob Dietle: yeah, yeah

126

:

Justin: about.

127

:

Like, maybe just talk about it at, like,

when do you graduate into that thing?

128

:

What is that thing?

129

:

And, um, and why does it really matter?

130

:

Jacob Dietle: Yeah, I think before

we get into that, just to give people

131

:

like all the buzzwords I see of it so

they can identify like, okay, that's

132

:

kind of what we're talking about.

133

:

First principles.

134

:

It's like AI company ran

context layer, LM wiki.

135

:

I think those are the big ones, right?

136

:

My version is a context OS

is what I happened to create.

137

:

But I really, what I think is gonna happen

is you have all of this, Information that

138

:

is, was previously like tribal knowledge

or was trapped in sales call transcripts.

139

:

Even if like before, like people

didn't have sales transcripts, so

140

:

it was even more trapped in like

this intuitive understanding.

141

:

and really what it is, is because AI

can just 10X whatever you give it.

142

:

If you give it a super, super

clear, well-thought-out process,

143

:

it can do that perfectly amazing

10 million times faster than you.

144

:

But you really have to think of it.

145

:

I think we underestimate how

well-defined the context you give it is.

146

:

And we're doing that just

for one process, it's hard.

147

:

But then doing that across all

of the processes of your company,

148

:

and it's a moving target, right?

149

:

You don't-- Your, your assumptions

around who your ICP is and how you write

150

:

messages to them changes all the time.

151

:

Your company's a living,

breathing thing, the people in it.

152

:

And then on top of that, the systems

in between them are always changing.

153

:

So I think going back to your

original question is like,

154

:

when do, when do you graduate?

155

:

what's gonna happen is, is you're

gonna see there's gonna be a few people

156

:

in your company that are like super

gung ho about experimentating, AI.

157

:

And generally, unless you have like a

top-down, you know, AI transformation

158

:

initiative, which some, some

companies do, some people, some don't.

159

:

Those are the people that are

actually gonna do the most

160

:

advanced cutting-edge stuff.

161

:

And they'll be like, "Hey, I'm using

Cloud Code or Codex or whatever.

162

:

You should try it because

I can get far more done."

163

:

And the reason you get far more done,

the big breakthrough between, between

164

:

like a regular ChatGPT or not, is all

it is, is these tools where these,

165

:

they have local agents, they can move

information outside of the context window.

166

:

The context window is just like

the memory the AI, the AI has.

167

:

So instead of being trapped with like,

you know, a million tokens is the

168

:

max, like, uh, it's kinda like RAM.

169

:

That's a good analogy for

people who aren't familiar.

170

:

Um, it can move stuff out and

then reference it back later.

171

:

So that's how it kinda

compounds on itself.

172

:

and as you get this compounding,

you get more and more things

173

:

that you wanna do with it.

174

:

And then you're like, "All right,

Justin, you should use my go-to-market

175

:

engineering dataset building skill."

176

:

It's like, well, how do

I get that skill to you?

177

:

Do I send it to you in Slack?

178

:

Yeah, maybe.

179

:

But then it's then stuck.

180

:

Then it's like, well, like, okay,

there's kind of this ephemeral thing

181

:

that's dangling, versus this is like

software has been doing decentralized

182

:

collaboration on code, using Git and

GitHub and this whole software development

183

:

lifecycle process of approvals,

184

:

but effectively, it's like the better

you govern your context and the more

185

:

explicit you have a chain of like, "All

right, this is why I made this decision,

186

:

and this is how we used this skill to

write this campaign," or ideate these

187

:

ad sets or whatever, the better you

can go back and say, "Okay, Justin,

188

:

Jacob created these types of campaigns

using these skills in their cloud

189

:

sessions, and we got these results."

190

:

And that it's really just about making

it easier to run that scientific

191

:

process of A/B testing or learning,

192

:

Justin: What you, what you said to me,

I'm like, all right, it, it addresses

193

:

like shareability, it addresses, like

how do we have a consistent way of doing

194

:

things across multiple people where

195

:

Jacob Dietle: Yep

196

:

Justin: learning compounds.

197

:

So it's like one important aspect of it.

198

:

What I often see is, you know, if you,

again, if you read on X, uh, these

199

:

things, which are perilous waters to,

to swim in, cause there's a lot of

200

:

Jacob Dietle: There's a lot of noise, yeah

201

:

Justin: A lot of noise.

202

:

you see people making these

massive things in, in GitHub that

203

:

look like, you know, huge either

relational databases or a series

204

:

Jacob Dietle: I know what

you're talking about.

205

:

Yeah

206

:

Justin: linking to each other.

207

:

And I, I've, I've been going through this

thought process myself recently because,

208

:

we're, doing some work on our own, where

I work at our own internal, AI stack.

209

:

We have a very comprehensive,

confluence and, and like

210

:

Jacob Dietle: Yeah, I remember

you telling me about it.

211

:

Yeah

212

:

Justin: you know, it's, it's

well-structured, it's not

213

:

perfect, but there's a lot there.

214

:

And it's like, do I need to like take all

this knowledge that we've already created

215

:

and built in one place and like convert it

into another format, into another place?

216

:

Like, does it need to live in GitHub,

or is that just sort of an artifice

217

:

of like, it's a lot of engineers

who are doing this in the first

218

:

Jacob Dietle: Yeah.

219

:

Justin: and, and so that's why it's there,

but it doesn't really need to be there.

220

:

Jacob Dietle: I would think of it

as, so everyone's figuring this out,

221

:

you know, this is a brand new thing.

222

:

It's really, it's like what are your end

business use cases you wanna solve for?

223

:

And like testing, all right, well, what

happens if I have the agent working out of

224

:

Confluence instead of with local files, do

I get the same or better results or worse?

225

:

Like what is the thing?

226

:

So much of it is like designing

t- what's your end outcome?

227

:

How do we test getting there?

228

:

And then working backwards, like

inverting instead of starting with

229

:

this, we wanna build this whole thing.

230

:

Start with outcome and

work backwards from that.

231

:

'Cause really like, uh, most of these

knowledge graphs are like kinda what

232

:

I'm, what I work with clients on.

233

:

It is this Markdown-based

system, but fundamentally it's

234

:

just a medium of collaboration.

235

:

I've seen people do it in Google Docs.

236

:

I've seen people do it in Notion.

237

:

Um, there are now these emergent context

layers for every, like for verticals.

238

:

like there's going to be a lot

of different ways to do this,

239

:

The tools are always gonna be

important, the specific tool chain.

240

:

Really it's about the principles, and

thinking about, all right, how can we

241

:

apply these principles to the tool stack

that we do have or can we, but that we can

242

:

support to then solve for these outcomes?

243

:

'Cause there are some companies that

are like, "Yeah, we built this insane,

244

:

custom embeddings and retrieval

and this whole really, really like

245

:

beautiful, elegant engineering thing."

246

:

But that's because they're like a team

of, like I don't know, making it…

247

:

They're 100 people and

99 people are engineers.

248

:

Like of course they're gonna

build something like that.

249

:

But if your, if your org isn't gonna

be able to support that, it's not

250

:

worth the, the, the effort basically.

251

:

- Justin: It's reminding me of like

the whole debate around like a

252

:

composable CDP versus a non-composable.

253

:

Like ' cus- customer data platform,

254

:

Jacob Dietle: it

255

:

Justin: sometimes you would buy this whole

thing, you would copy your data over into

256

:

it, and then you would have this whole

activation layer sitting on top of it

257

:

there, versus a lot of companies started

rolling out this idea of a composable CDP,

258

:

which would sit on top of your warehouse.

259

:

So essentially your data

could stay where it is,

260

:

Jacob Dietle: I see

261

:

Justin: then they would roll

this activation on top of it.

262

:

Jacob Dietle: you

263

:

Justin: And wondering like, all right,

if you were coming in to advise us today,

264

:

I'm like, "Look, I have all my docs

already organized in, in Confluence.

265

:

Is there a benefit in essentially

copying them over into another system

266

:

and like organizing them differently?

267

:

Or would you, would you be more inclined

to work with my docs like where they

268

:

are and say, 'Yeah, let's just like

kinda access this and just more like

269

:

point it in the right direction?'"

270

:

Jacob Dietle: I think the big

thing I start with is like,

271

:

it's usually never either/or.

272

:

A lot of times it's, it's both and all of

the above or some combination, especially

273

:

for different people in the org.

274

:

Like, I think of it as, um, like

concentric circles of like who

275

:

needs to be really working on the

system and who needs to be s- maybe

276

:

getting the benefit of the system.

277

:

You know, at the very center, it is

probably going to be you have your

278

:

cloud code or Codex or whatever in

the Confluence, and maybe be, you do

279

:

need to be governing the org skills.

280

:

So those are gonna be marked down because

that's how those agents acc- access those.

281

:

You wanna version control those using

Git, and that often will mean GitHub.

282

:

but maybe you do, you know, each

scale is grounded or has a, you

283

:

know, unique, unique identifier

back to Confluence or something like

284

:

that you can, like, a- associate

across your s- different systems.

285

:

and that's why I focus so much on

the principles and thinking about

286

:

like what is the most effective way

to use these engineering principles

287

:

to get value for the business?

288

:

'Cause you can spend…

289

:

Like the, another big buzzword I, I

fret speaking of the big ideas of,

290

:

of, um, on, on Twitter and X is like

you hear the word ontology a lot.

291

:

Ontology is just, it's like a s- it's

a school of philosophy where it's like,

292

:

what are our, our entities in the world?

293

:

In the philosophical sense, it's like,

well, how do we ha-- What is the,

294

:

what is reality structured of and

like what are the entities in that?

295

:

Right.

296

:

Palantir made it very popular for

their like ontology system for, you

297

:

know, government military tracking.

298

:

But the point I'm trying to make here

is like people have been thinking about

299

:

classification systems for like thousands

of years, and there's no perfect one.

300

:

So like find, just find a system that

works for your given constraints,

301

:

unless you wanna go be an ontologist

and like that's your thing.

302

:

Justin: That's a healthy,

that's a healthy perspective.

303

:

So I mean, like thinking about your

concentric circles, if, if a company

304

:

brings you in for a project, are you

typically starting and saying like, "Let's

305

:

just create your, context layer for like,

outbound sales or for go-to-market," or

306

:

like a, a, a narrow slice of the business?

307

:

Or is it more a holistic project

of like, "No, we're gonna build it

308

:

company-wide," or, or can it be either/or?

309

:

Jacob Dietle: It, this is something

I, I go back and forth on.

310

:

'Cause usually what, what I've found

is st- you start with a, a, a s- s-

311

:

simple vertical, and you kinda use

that to build out either to, like,

312

:

other parts of the go-to-market motion

or maybe other, other adjacent teams.

313

:

The way I think of it is, like, all

these context systems are very much…

314

:

A good way to think about

them is, um, like recipes.

315

:

So, like, if you have 10 ingredients,

right, you can make dozens of unique

316

:

recipes reusing those ingredients.

317

:

And you're gonna oftentimes in

your kitchen, you keep the stuff

318

:

that you reuse the most, right?

319

:

So your eggs and your butter

and your stuff like that.

320

:

You can make bread and all these

cakes and pasta and whatever, right,

321

:

from scratch if you really need to.

322

:

So if you think about context like that,

it's like what is the stuff that our, all

323

:

of our teams are going to need, or all

of the go-to-market team is gonna need?

324

:

It's like maybe if you have a super

complex product, um, you probably

325

:

wanna represent that very clearly

in, in context because everyone can

326

:

reference that in if they're doing

product marketing or if they're doing,

327

:

content writing The, the reason I

like this system is 'cause it makes it

328

:

easy to reuse and find the next thing.

329

:

Like once you sit down and like do

this for like an hour, you're like,

330

:

"Oh, I've mapped like 80% of our like

core business for maybe one team,"

331

:

or something like that into, like,

it compounds itself very quickly

332

:

Justin: Do you like to start there?

333

:

Like sort of like, all right,

let's just get something out

334

:

that is like maximally valuable

335

:

and takes the least time

and then build on there?

336

:

Or is there a certain threshold of, of

completeness that you need to reach?

337

:

Jacob Dietle: Like any engineering

problem, you get diminishing

338

:

returns at a certain point.

339

:

So I might-- I'd rather find like,

"Hey, what like top three things

340

:

we're gonna get value out of?"

341

:

And that also helps me understand like,

well, how does the business actually work?

342

:

'Cause all of these nuances and

context is very, very good when you

343

:

capture those nuances and can get

those into, get them into the prompts.

344

:

Like one thing, like I remember when I got

like, uh, one of the systems I first got

345

:

into their hands, they were able to find

so many things about weird little niche

346

:

like things customers were asking for that

they didn't realize was a huge competitive

347

:

advantage to like a different platform.

348

:

just because they can sit with it and

like you keep on pulling on the thread

349

:

and the, the easier it is to pull on that

thread and then capture that, oh, they

350

:

like our platform more because we don't

force them to sign up before starting to

351

:

use it or whatever the example is, right?

352

:

all those things when you capture them

and then turn those into explicit context,

353

:

it starts building on itself very quickly

354

:

Justin: One that you just mentioned

is interesting 'cause that's like…

355

:

it's, uh, an insight, a s- a synthetic

insight that you would gain from like

356

:

let's say listening to multiple calls over

357

:

Jacob Dietle: Yeah

358

:

Justin: patterns.

359

:

did that become part

of their context layer?

360

:

Like did you just provide all

the calls and then through

361

:

working with it people got that?

362

:

Or was there some kind of like

before it entered the context layer?

363

:

Jacob Dietle: a, I have a process for

ingesting like raw context, so to speak,

364

:

and then turning it into that graph.

365

:

the big thing there is like

the first graph is never

366

:

going to be like 100% right.

367

:

And I tell, I tell my clients

like, "This is work in progress.

368

:

There's gonna be things that are

wrong in there, and there's things

369

:

you're gon- you're not gonna like.

370

:

But in the process of building the thing,

we're gonna, we're gonna iterate, on it

371

:

a bunch and we're gonna learn a ton."

372

:

And through that, it's like

instead of having to listen to 10

373

:

hours of, of sales calls, right?

374

:

And like to gather all these insights, it-

we can do it in 30 minutes basically of…

375

:

You know, it's, it's almost

like a time compression.

376

:

And the better you can compress without

losing that information, the better.

377

:

And that's what these systems

are very, very good at.

378

:

Justin: Graph sounds very cool.

379

:

Like, what does it mean in this context?

380

:

A graph of, of like that kind of

381

:

Jacob Dietle: Yeah.

382

:

The big thing is the graph is, is

a means to creating a, chain that

383

:

can ground the language model.

384

:

So the example here, and like we're using

the sales transcript one, is like if we

385

:

have an insight that is customers like

the-- our platform more because we don't

386

:

force them to make an account before they

start using it, anywa- that has to be

387

:

grounded in some sort of claim somewhere.

388

:

And that's where you get these

relationships of this insight is

389

:

from these specific lines in these

transcripts that are also in the system.

390

:

You don't really use

those transcripts a lot.

391

:

going back to like the RAM analogy,

those are almost like your hard drive.

392

:

It's like you have all the old,

old stuff in there that you don't

393

:

really need often, but you still

need to be able to reference them.

394

:

In RAM, you're like reading

and writing from all the time.

395

:

So you-- that's the full chain

all the way back from, all right,

396

:

all these transcripts, you know,

let's say you started by asking the

397

:

agent, " Here's the exact process

I would use to go look for insights

398

:

across our, our sales transcripts."

399

:

And you can transcribe your exact

process, think it through out loud,

400

:

then turn that into a scale, and

you have a bunch of sub-agents.

401

:

And the sub-agents then will, though,

connect those dots for you, generate

402

:

that like intermediary graph layer,

and then okay, then you go, "Perfect."

403

:

This is the like grounded, verified,

kind of like structure going from, "Hey,

404

:

we wanted the, we wanted novel insights

that we didn't have before," all the way

405

:

through to the agents running across the

whole thing with then verified claims

406

:

in a grounded like provenance chain.

407

:

Justin: what you're saying

is shifting my perspective a

408

:

little bit around what it is.

409

:

Because to, to my earlier question

that I was poking on around like, is

410

:

it just taking my Confluence knowledge

and moving it to someone else?

411

:

So you, you may have in Confluence like,

"This is our ICP, - here's our current

412

:

messaging, here's our positioning."

413

:

it-- And that may be based on that sort

of analysis that you just described.

414

:

But what you're talking about is actually

coming in and producing new knowledge

415

:

that didn't exist before for the

company, and then representing that in a

416

:

structured way, which is very different

than just, "I'll take your existing

417

:

stuff and make it agent accessible."

418

:

Jacob Dietle: Yeah, that's

actually good to think about it.

419

:

I'm gonna steal that.

420

:

I love the, I love the knowledge.

421

:

You like just perfectly like compressed

and made it so much more simpler.

422

:

I love that idea.

423

:

Yeah, I think that's really what it is,

is like, it's like how do you quantify

424

:

the value of knowledge or an idea?

425

:

It's like everyone knows the

right idea could be like worth

426

:

everything, but it's very hard, um,

until you see it in front of you.

427

:

That's why what, what I find is like

most people will-- like it'll click

428

:

for them once they like pull it inside

out themselves and they're like, "Oh, I

429

:

can do th- I can use this to do what?"

430

:

Or, "I can use this to go…"

431

:

Like all of our, every single piece

of our marketing can be, should be,

432

:

and can be grounded in a real customer

insight or something like that.

433

:

Plus our, you know, unique taste and

perspective, about what we do and why.

434

:

that's why I really love the recipe

analogy, 'cause once you think of it

435

:

that way, it becomes this composable way

to like almost manufacture new insight.

436

:

And not, not, not to manufacture

new insights, but like what is the

437

:

way we can like set up a machine to

do this for us on a regular basis?

438

:

Justin: that analogy really

landed with me as well.

439

:

And then so is the context

OS primarily composed of you

440

:

know, synthesized insights?

441

:

Or is insights just one type of

knowledge, and then there would

442

:

also be our processes, our business

rules, even maybe our raw data?

443

:

What is the-- what is it composed of, the

444

:

Jacob Dietle: Yeah.

445

:

I

446

:

Justin: knowledge?

447

:

Jacob Dietle: this, is where it

gets into the system conforms very

448

:

much to like each, almost like it

conforms to each business, but also

449

:

the people who drive it the most.

450

:

I really like the, Processes and

like work streams based approach

451

:

of like, this is really for

creating these types of outcomes.

452

:

But like I know other people like really

like to model the whole business of

453

:

like one way of doing it, like subject

object predicate of like this object

454

:

has this relationship to this thing.

455

:

and you can get more, you

know, maybe semantic like

456

:

information density with that.

457

:

But like I said, it's like really

this trade-off of how much do

458

:

we need to model in the system

to make it usable for our goals?

459

:

and that's why you can go get Palantir's

four deployed engineers to model

460

:

literally every single entity in the

universe basically, 'cause they need

461

:

an entity for, I don't know, a tank.

462

:

But like for you go to Mark of Motion,

you don't need to have an entity for

463

:

tanks because you're not dealing with

tanks or something like that, right?

464

:

Justin: I hope, I hope

465

:

Jacob Dietle: Yeah, right.

466

:

It'd be a bad day.

467

:

Justin: What you just described, I

think is extremely intellectually

468

:

appealing, uh, to me and presumably

to a certain class of, of people

469

:

who would just love to feel like the

whole business is mapped, everything.

470

:

It's like, I would be at real

danger, and I'm, you know, old

471

:

Jacob Dietle: But

472

:

Justin: now that I kind of

recognize this in myself.

473

:

Jacob Dietle: yeah,

474

:

Justin: of just like focusing on that.

475

:

Jacob Dietle: you go down the rabbit hole.

476

:

Yeah

477

:

Justin: go, I'll go down the

route like three years later,

478

:

"Hey everybody, I mapped the whole

479

:

Jacob Dietle: I have the perfect business.

480

:

Yeah, yeah

481

:

Justin: it's the pre-- now the

business has changed maybe.

482

:

Jacob Dietle: Yeah

483

:

Justin: like when I look at what actually

drives value in the, uh, agentic work

484

:

that I'm, uh, that I'm doing day to

day, um, it can be very domain specific.

485

:

Jacob Dietle: Exactly.

486

:

Justin: a great example for me was

like, um, in our, uh, in our Salesforce

487

:

org, our, our Salesforce, architect,

created a bunch of rules and skills for

488

:

Claude that mapped out exactly how to

work within our Salesforce org, what

489

:

the development life cycle looks like,

490

:

Jacob Dietle: Nice.

491

:

Yeah

492

:

Justin: can go ahead, can't, whether

we prefer Apex or Flow, permission

493

:

sets, that whole thing, so that

Claude, you could just drop in a

494

:

task and it's like, "All right, you

know, checking my, uh, prerequisites.

495

:

Great, I have them.

496

:

I'm

497

:

Jacob Dietle: Exactly.

498

:

Justin: build.

499

:

I

500

:

Jacob Dietle: Yep

501

:

Justin: build."

502

:

I'm like, "Wow."

503

:

But that was like such a narrow domain.

504

:

It didn't need the whole business.

505

:

It wasn't graphed per se.

506

:

It was just like the right process.

507

:

And so I'm wondering, in other words,

like how, much is it really important

508

:

to have that like crystalline entity

of everything relating versus like,

509

:

let's just find some high leverage use

cases and like document those really

510

:

well and make them easily accessible?

511

:

Jacob Dietle: I

512

:

think,

513

:

Justin: should we

514

:

be,

515

:

Jacob Dietle: think, I think

you should be very pragmatic.

516

:

Um, like that's my point of view is

like, don't-- you don't need to model

517

:

every single entity in the business.

518

:

It's-- But it's really like you--

like the marginal cost to take that

519

:

skill and then be like, "Well, what

does this actually connect to?"

520

:

Right?

521

:

After we finish this process,

what does it connect to?

522

:

And like, what's the contract between

that skill, um, the one you're talking

523

:

about, and the next step in the business?

524

:

That's really where it's valuable.

525

:

And like if you start at these

individual atomic chains, then suddenly

526

:

you'll find yourself using the recipe

system, mapping a, a good portion of

527

:

the business in a very pragmatic way.

528

:

It's not gonna be perfect, but

like it's gonna be valuable,

529

:

and that's what matters.

530

:

Justin: If I, if I take a real example

there, we did build the development

531

:

part and then we linked it to the

request part so that we could see

532

:

how the request came in, and we

then also linked it to the QA part.

533

:

So that's what you're

saying is holding true.

534

:

But then I'm like, all right, what's

the next jump outside of that?

535

:

Would it-- Like, 'cause it's

a big leap from there to like,

536

:

well, I guess what are our OKRs?

537

:

So in order to evaluate the request, you

would need to know the business context of

538

:

like are our actual objectives right now?

539

:

What are we trying to achieve?

540

:

Is that the right way to think about it?

541

:

Jacob Dietle: Yeah, exactly

542

:

Justin: the, how a me- a

meaningful connection to the next

543

:

Jacob Dietle: You know, the meaningful

connection to the next layer.

544

:

And then the thing that is, I

think maybe the next step in this

545

:

whole process is versioning, right?

546

:

Let's say there's three

steps in this thing, right?

547

:

Versioning all of them so

you can go, "Okay, this was

548

:

our process three months ago.

549

:

How did this process

change from then and now?

550

:

And like, what results did we get by

changing each part of the recipe?"

551

:

And like that's so you get this like--

And the whole point is to make it easier

552

:

to learn and like man- make this new

knowledge basically by running the

553

:

scientific process in some way or another.

554

:

it's just like making sure you can go back

and reference things and be positive that

555

:

you like have real empirical evidence that

this h- this change yielded this result

556

:

Justin: What you're describing

is where, my mind starts to fold

557

:

in on itself a little bit when

I think about representing it,

558

:

Jacob Dietle: Yeah.

559

:

Justin: on the one hand you have

almost just like stateless knowledge.

560

:

Like these are, this is a set of

facts that are true at this time.

561

:

That's all the agent knows.

562

:

And then you're now describing almost

like a time series of facts that were true

563

:

that, you know, things that may be true.

564

:

how do you start representing

that in a way that doesn't

565

:

become overwhelming to maintain?

566

:

Jacob Dietle: I think automating a

lot of the, like, capture process.

567

:

So that's what Git is…

568

:

Git is very good at this, right?

569

:

So Git was literally made because Linus

Torvald, the creator of this, was like,

570

:

"How do I collaborate with people on

Linux across different time zones,

571

:

across the whole world basically?"

572

:

, It's actually a graph in itself.

573

:

People-- Most people think Git is like--

I especially, I understand why it happens.

574

:

I had to go teach myself

very specifically, like,

575

:

why does Git work this way?

576

:

But Git is, it's called a

DAG if you wanna look it up.

577

:

But basically, like it's a graph that for,

that has multiple connections, and you can

578

:

kind of merge things into the connections.

579

:

to make that concrete, like you

have one version of our s- of our

580

:

shared skill for the Salesforce,

and I have another version.

581

:

You and I basically need to be like,

"All right, well, the top 100 lines

582

:

of the skill and the bottom 100 lines

of the skill didn't change at all.

583

:

But we both made different

changes in, to the middle 50."

584

:

we wanna merge these together

to have a semi-unified skill.

585

:

You and I are both gonna submit a pull

request, and like we're gonna discuss

586

:

back and forth, which all it is like we're

reviewing we have to chat back and forth

587

:

about, "All right, well, this part does

this thing, this part does this thing."

588

:

I'll f- We, we'll meet each other

fif- 50/50, your 25 lines, my 25

589

:

lines, and that gets merged in.

590

:

And then that new, that new version

has a full chain of like Justin,

591

:

Jacob, you know, had this pull request

conversation back and forth, and this

592

:

is why they made the decision they did.

593

:

That's the way to do it effectively.

594

:

It's just like, look like

Wikipedia has this as well.

595

:

It doesn't use Git, but they have their

own kind of like review process of like

596

:

this article has cha- changes throughout

the years and like we can go back and see

597

:

what part of the article changed at what

point in time and like why it changed.

598

:

And that's, that's the whole process.

599

:

Justin: So there's provenance and there's

history, and if I'm understanding you

600

:

correctly, you're not capturing that

within the text of an MD itself, but

601

:

just relying on Git's native ability

602

:

Jacob Dietle: Exactly.

603

:

Yeah

604

:

Justin: to capture that and,

and the agent's ability to like

605

:

walk that, that Git structure

606

:

Jacob Dietle: Yeah, exactly.

607

:

'Cause the alternative is then..

608

:

Like I've done this as well because

it's like the easiest thing, is like

609

:

you get, proposal draft version one.

610

:

Proposal draft version one,

two, three, four, five.

611

:

Proposal draft version 49 final, final.

612

:

And like this…

613

:

Justin: I don't even wanna

work with this client anymore

614

:

Jacob Dietle: Yeah, and you're like,

615

:

Justin: 49.

616

:

Jacob Dietle: yeah, whatever.

617

:

Like, but like that, that's the stream

version, but like we all kind of know the,

618

:

um, like th- this back and forth, right?

619

:

This is what Google Docs did so

well, um, with Word doc editing, is

620

:

like it kind of, it kind of, you had

the living document and you could

621

:

go and see the h- version history.

622

:

Like you go in and see the history,

and you could do comments, and it

623

:

solved the huge collaboration problem,

which was like emailing stuff back

624

:

and forth all the time , right?

625

:

This is, Git was doing that for

software engineers, and now that

626

:

we're like figuring out like, oh wait,

we need like context to be explicit

627

:

if our agents are going to be good.

628

:

Now it's a big open question

of like what's the best way to

629

:

manage this context life cycle?

630

:

Um, and Git is like kind of the natural,

um, option because it has been, you

631

:

know, been used for 25 year or 20 years,

um, for stuff like exactly like this.

632

:

Justin: And so the reason why this

might be important in practice once

633

:

we've solved, you know, how does it

do it, is maybe like you're working

634

:

on an outbound campaign, since a lot

of this stuff seems to, to relate

635

:

to outbound use cases, I find,

636

:

Jacob Dietle: Mm-hmm.

637

:

Justin: you're considering a certain

message, and then the agent can

638

:

be like, "Actually, we tried that

message like four experiments ago,

639

:

Jacob Dietle: Exactly.

640

:

Justin: overwritten because

the results weren't good."

641

:

That's sort of

642

:

Jacob Dietle: Yeah.

643

:

Justin: it matters?

644

:

Jacob Dietle: It's, it, it takes,

like, it, it, the ideal is it takes

645

:

something you've already learned

and makes it your starting point.

646

:

Like, without having to do any work.

647

:

It takes, it takes everything

the business, the org has learned

648

:

at some point or another, and

that's your new starting point.

649

:

You don't have to go down all these other

possible trails that, that have already

650

:

been explored, um, that are dead ends.

651

:

So it's a kind of like, like it's

almost like reasoning by negation.

652

:

Like instead of trying to be like,

"What is the best thing we could do?"

653

:

It's like we're just eliminating

all the things that don't work.

654

:

and that becomes this like

feedback loop over time, right?

655

:

Someone else can like eliminate

these trails for you, and that way

656

:

you can like, you know, you, you can

get better outcomes for your effort

657

:

and time just because you don't have

to go explore all those dead ends.

658

:

Justin: And then in terms of how

these files then like relate to each

659

:

other, everything we just talked

about you could think of as just being

660

:

even about one sort of domain or,

661

:

Jacob Dietle: Ja.

662

:

Ja.

663

:

Justin: area of facts,

let's say messaging.

664

:

what is the m- the m-

the message that we use?

665

:

then that relates to other things

like different personas, different

666

:

segments, and there's different ways

of doing this, like links or, uh, like

667

:

wiki style links or does it matter?

668

:

Or just the agent needs something that it

can cleanly and consistently interpret?

669

:

Jacob Dietle: I think, I think there's

something of like, maybe you should

670

:

go do a little bit of research on

the different ways to represent this.

671

:

like I mentioned, domain-specific,

um, context layers, like Octave

672

:

does this very, very well for

like enterprise go-to-market.

673

:

Like they have an opinionated ontology,

674

:

Justin: Угу,

675

:

Jacob Dietle: um, but it's worthwhile

because they're the ones like really

676

:

thinking about why all of this should

fit together, and you're basically

677

:

taking their opinionated, ontology

instead of like rolling your own.

678

:

like, you know, for other instances,

you like really want your own version.

679

:

You want to be able to read

and write from it often.

680

:

so there's, there's kind of like

a decision framework on Is it

681

:

worthwhile for our use cases?

682

:

Like if we have 150 reps - and we just

need them to like be able to read from

683

:

the system, and it's just go-to-market

specific, it works really well.

684

:

Do we need to spend time like

getting them all using cloud code

685

:

and all that stuff like that?

686

:

It's like probably not what they should

be doing with their time, you know?

687

:

So it's like, all right, then are we

gonna build our own system or maybe

688

:

do something like Octave, right?

689

:

I think there's kind of like, again, like

reason by negation of like what do we

690

:

actually need to solve for our end result?

691

:

If you're an engi- if like going

back to that, that example of an

692

:

engineering world building their

own very custom crazy system, right?

693

:

That's probably super valuable because you

have so much information in the code base.

694

:

And weirdly enough, like the way you

represent the code base or some--

695

:

'cause so much coding is now agentic,

the way you work on the code base

696

:

is kind of through these like, um,

context layers, like context as code.

697

:

Really thinking about that as

like the machine to build the

698

:

machine is super, super important.

699

:

so it's all about these like kind

of trade-offs I would think about.

700

:

So for most stuff though, for like

a, uh, like a basic like LLM wiki or

701

:

context OIS, like taking, your end use

case and like what would I actually

702

:

need to represent in the system?

703

:

And it's like probably

like four or five things.

704

:

I'm like, all right,

great, and just test it.

705

:

And just like, just do like

ruthless empiricism of like,

706

:

do I actually need this?

707

:

No.

708

:

Get rid of it, and test it that way.

709

:

Justin: So I maybe just want you to

help me think through, like, the agent's

710

:

experience of navigating this context.

711

:

So

712

:

imagine, like, I'm an LLM.

713

:

Jacob Dietle: Yeah

714

:

Justin: I, I wake up, it's like

"Severance," you know, like

715

:

show-- if you've seen that show,

716

:

Jacob Dietle: Yeah, yeah.

717

:

Justin: on the

718

:

Jacob Dietle: You know nothing.

719

:

Yeah

720

:

Justin: "I'm, I'm just here."

721

:

Okay.

722

:

And then you get certain

information passed to you.

723

:

You have a, a system prompt, you have

a request, specific user request, How

724

:

much of this context is, like, inserted

automatically for it in, in an ideal

725

:

world, how much of it is the agent

then needs to go and, like, retrieve?

726

:

So it's like, all right, I've got like

a filing cabinet, and I know how to go

727

:

Jacob Dietle: Mm-hmm.

728

:

Justin: look up some of this

information that I need.

729

:

And like, and furthermore, just to make

this an even harder question to answer,

730

:

Jacob Dietle: Let's do it.

731

:

Justin: it?

732

:

Do

733

:

Jacob Dietle: Yeah

734

:

Justin: it, is it just like, is it

grepping and searching for keywords?

735

:

Is it, semantically searching

for like something similar?

736

:

What is, what is that experience like?

737

:

Jacob Dietle: I think it's-- So the

big thing with all of this is the

738

:

idea of progressive disclosure, which

all that means is like you give it

739

:

a little bit of information that

tells it how to get more information.

740

:

And this is something that the CogCode

team has talked about a lot, is

741

:

like have a very lightweight file.md

742

:

or agents.md,

743

:

all it is, is like, "Hey, this

is the system you're working in.

744

:

This is how you go get more information.

745

:

These are the rules on what

you can and can't give."

746

:

And like defining search

strategies of like using that,

747

:

call transcript example earlier.

748

:

It's like, well, you don't wanna tell

it exactly how to like go through every

749

:

single call, um, in the first file because

it's not always gonna be doing that.

750

:

So let's give it a skill which

it'll-- it can go call when it

751

:

needs to go do transcript analysis.

752

:

And it's kind of just layering on

this idea of progressive disclosure on

753

:

like a modular level you have, these

building blocks, what's the best way to

754

:

fit them together, in a way that it's

flexible, adaptable, but you're not

755

:

giving it everything at once, basically.

756

:

Justin: And then from

a retrieval strategy,

757

:

Jacob Dietle: Yeah

758

:

Justin: like a, uh, like a f-

like a file system type b- kind

759

:

of way of retrieving information?

760

:

Is that better?

761

:

Should it be searching semantically

is it both depending on the scenario?

762

:

Jacob Dietle: Uh, I mean, there's a

million different ways to, to solve this.

763

:

There's-- Especially de- like going back

to like, I'm sure Confluence has its own

764

:

extra API and Notion, uh, I think does

vector embeddings of a workspace for you.

765

:

But I, I do really like the lexical.

766

:

So the k- the, the fancy word

is the lexical agentic search.

767

:

All that is, is calling code

another agent using its low ability

768

:

to write commands to do grep and

glob and like search across it.

769

:

and that's-- I like that because it's

one, it's, plain English still, right?

770

:

Semantic embeddings, it, it

takes your documents and turns

771

:

them into math and both, it's a

mathematically similar, thing back.

772

:

But with the lexical search, you get

that real like, all right, we went from

773

:

this document to this document, to this

document, to this specific line in this

774

:

document, and did that three times over,

and that's what the chain we navigated

775

:

to go get the, the new piece of knowledge

about our customers, really like on our

776

:

platform 'cause we don't have to sign in.

777

:

And that's where you get that

whole chain all the way back.

778

:

You could do that with other search

approaches, but because it's simple

779

:

and effective, I really like that one.

780

:

That's my preferred.

781

:

And I think that's just like, that's what

most agents and kind of stuff defaults

782

:

to anyways, 'cause it's just, it's better

in a lot of ways for most use cases.

783

:

Justin: Is semantic search overrated?

784

:

Do you think it's gonna sort fade away?

785

:

Like, it sort of started out as like this

is, this is how agents should search and

786

:

then there was like the era of like all

you need is file systems and like whatever

787

:

Jacob Dietle: Yeah

788

:

Justin: which, which is, it seems your

position is closer to that second place.

789

:

I'm not intending to parody it.

790

:

I'm more just

791

:

Jacob Dietle: No, you're good.

792

:

Yeah,

793

:

yeah,

794

:

Justin: ex, the ex, echo chamber of,

of how all that stuff is expressed.

795

:

do you think that's where we'll stay

'cause it actually just is more effective

796

:

or do you think there's room for both?

797

:

Jacob Dietle: I think you're doing both,

but I think for most use cases, like

798

:

semantic search is like if you have like,

do you have like 10 million documents?

799

:

You should probably go

vectorize those, right?

800

:

For what we're talking about for

these types of systems, you don't

801

:

get above, I don't know, a thousand.

802

:

And then you have to start thinking about

like, then there's like, well, this, is

803

:

this context that should live in this

kind of knowledge graph type of thing,

804

:

whether your context or your markdown,

or should it live in a data warehouse?

805

:

And then you oftentimes you need both

the context graph and the data warehouse

806

:

or CRM or, or something like that.

807

:

Justin: One of my, um, favorite things

to do sometimes is to just, like, talk

808

:

to, uh, existing chat products and,

like, try to reverse engineer them a

809

:

little bit when they're willing to do

810

:

Jacob Dietle: Yeah.

811

:

Justin: And I found that, ChatGPT

work, so for anyone that uses the

812

:

ChatGPT mobile app, they have, like,

a chat mode and a work mode, and the

813

:

work mode is, like, kind of similar to

Codex but in a cloud, uh, environment.

814

:

and it's, it's more

open about how it works.

815

:

I remember asking it, like, 'cause

it referred to something that I

816

:

said in another chat, and I'm like:

Oh, I'm really curious, like, how

817

:

are you-- how do you know that?

818

:

And it kind of was able to unpack

a little bit of, of, like, how its

819

:

context engineering was working.

820

:

It's like: Well, I, I see your latest

question, and then I see, like, a summary

821

:

of, like, hot topics from across all

your chats, and then I see, like, the,

822

:

some of the most recent things we talked

about, and then a much more compressed

823

:

summary of, like, even older things.

824

:

So it gave a little bit of a

bird's eye view for whatever, if

825

:

we can trust the accuracy of that.

826

:

So that is more in, like,

a user fa- almost like a, a

827

:

productized chatbot environment

828

:

Jacob Dietle: Exactly

829

:

Justin: almost a lot more the context for

the user versus what you're talking about

830

:

where it's a lot more like, like a trusted

co-pilot to a skilled user who's gonna…

831

:

Do you see those as being

two separate situations that

832

:

Jacob Dietle: Yeah.

833

:

Justin: have two different strategies?

834

:

Jacob Dietle: I think of it as this way,

is like, because you're letting the,

835

:

you're letting the system do the context

engineering for you, you don't actually n-

836

:

you, you have less insight into as to why

it's producing the results it's going to.

837

:

And if you're using the systems to,

like, make business critical decisions,

838

:

not having that sort of insight can

be maybe not dangerous, but you're

839

:

like, you just don't have insights.

840

:

You don't understand what's going on.

841

:

It's like anything that's like sometimes,

yeah, you just want the answer to

842

:

work well, and for most consumer

products, like it's gonna be the,

843

:

the man- the managed context system.

844

:

But it's like, how much effort

are you gonna put in to,

845

:

to get the result you want?

846

:

And more and more, I think context

is not going to, is not just going to

847

:

become like a, a important way to, you

know, maybe drive better go-to-market

848

:

results or campaign or whatever is the

metric you wanna pull, but like a, a huge

849

:

competitive differentiator on like how

fast can we iterate on our core product,

850

:

and go from a hypothesis to, a product

feature change to the campaign around it,

851

:

to shipping everything and like making

a real impact in the re- real world.

852

:

And that is like very much explicit

information system engineering

853

:

problem that is mostly context shaped

854

:

Justin: So if we think about like

like, you know, Jacob maintaining

855

:

his local context OS on his computer

is one type of problem, a company

856

:

maintaining this and updating it and

governing it across 400 or 4,000-person

857

:

Jacob Dietle: It's a

very different problem.

858

:

Yeah.

859

:

Justin: of problem.

860

:

And like how do you, how

do you think about that?

861

:

Jacob Dietle: So you, you have

all these problems at one person,

862

:

and then two people, and then a

team, and then multiple teams.

863

:

Each step in that is like almost like

this, like kind of exponential, of

864

:

you have all of the problems of the

f- other layer, the, the preceding

865

:

layers, and then the new problems.

866

:

So each one builds on itself, and you have

to solve layers one, two, three, uh, all

867

:

combined to then even get access to four.

868

:

And then four is like as complex

as all the one, other ones

869

:

combined, plus its own problems.

870

:

and the way I think of this

is like you don't want to…

871

:

Like any-- The, it becomes both

a, like engineering problem and

872

:

like a, a people process problem.

873

:

And the way I think about the, my current

thing I'm, I'm working on with, with

874

:

clients and my current hypothesis is you

don't want to like really have this like

875

:

super top-down structured, rigid, way of

like this is how things are done because

876

:

that kinda limits what people can do.

877

:

Instead, you really wanna think

about like, "Hey, people are already

878

:

doing really cool stuff with AI," or

they should be, or there's like some

879

:

way to train them or, or whatever

the state your business is in.

880

:

It's like how can we create five

core rules that allows for d- all

881

:

this decentralized collaboration

or five core systems or whatever

882

:

the unit of, control is?

883

:

In engineering, this is

called, a constraint.

884

:

Like what are the things that we're gonna

make that have to be true about our system

885

:

that allows everything else to work?

886

:

and like this is like kinda

how United States works.

887

:

Like it's a federal public.

888

:

There's a federal government like

who has its own system, but the

889

:

states then govern themselves.

890

:

And there's an agreement between like

the states can do this stuff and the

891

:

federal government can do this stuff.

892

:

And that's how like you get this like

decentralized collaboration where the

893

:

federal government is not always telling

each state what to do all the time.

894

:

That's just not, it doesn't

make any sense, doesn't work.

895

:

Justin: if we think about these sorts

of updates, a, a metaphor that I see

896

:

used sometimes more often in memory,

but memory is just another type of

897

:

context, I guess, of like dreaming.

898

:

So almost like an agent that comes in

899

:

Jacob Dietle: Like self-learning?

900

:

Yeah.

901

:

Justin: self-learning, uh,

902

:

Jacob Dietle: Yeah

903

:

Justin: reviews traces,

and then it suggests…

904

:

I could envision a world, let's say

you've got your context OS in GitHub, this

905

:

agent runs on a cron every night, reviews

sessions, like learns some stuff, and is

906

:

like, puts up a PR that says, "I would

propose an addition or a modification."

907

:

Is that something that you've seen

in practice, or is that a good idea?

908

:

Jacob Dietle: Yeah, I

think it's a good idea.

909

:

It's very hard to get right.

910

:

It's like way-- It's very,

very hard to get right.

911

:

So that, I think that's why it's always

like you have that pull request process.

912

:

So the whole thing, right, fitting

it all together, like you have that

913

:

federated system of the go-to-market

team has their skills, but there's a

914

:

core company context, and the sales

team has their other skills, and

915

:

like there's that federated system.

916

:

and there's an explicit rule process

of this person owns this context,

917

:

and there's this version of this

context, and the owner has to

918

:

review a pull request to create a

new version of that context, right?

919

:

Then that enables that self-loading

process, because then you can have,

920

:

instead of a person having to make a p- a

PR request, you can have an agent fit into

921

:

that established decentralized system.

922

:

and that's what enables that to happen.

923

:

But then you have a whole new process

of like, well, how do we engineer the

924

:

agent to get the right information?

925

:

And like, what's our process for

reviewing this thing, you know?

926

:

generally what I find is like, do it

a few times manually, and then you

927

:

can get set up on a, on a recurring

basis, to really create like end value.

928

:

Justin: Everybody wants to start

with like automated self-learning,

929

:

Jacob Dietle: it, exactly.

930

:

But like you, yeah, you, you

don't know what you actually want

931

:

until you go do it yourself at

least once or tw- or two times.

932

:

Yeah

933

:

Justin: Jacob, this was super interesting.

934

:

quick shout out for you, like

what types of companies do

935

:

you ideally like to work with?

936

:

Where can they find you if

someone's like, "I need help with

937

:

Jacob Dietle: Yeah.

938

:

So I mean, LinkedIn is the

best place to s- to find me.

939

:

I think I'm posting on there probably

too much and too little at the same time.

940

:

I generally work with seed Series

A companies where there's like

941

:

some sort of like AI direction

for, go to market, but they really

942

:

wanna take it to the next level.

943

:

it's a really fun process for me to

kinda jump in, find those use cases.

944

:

All right, this is the context

system we're gonna build out.

945

:

This is the people we're gonna train,

and this is the end value we're gonna,

946

:

we're gonna create for this system

947

:

Justin: Love it.

948

:

We'll include a link, to your LinkedIn

and your website in the show notes.

949

:

Thank you so much for doing

950

:

Jacob Dietle: Yeah.

951

:

Thank you, Justin.

All Episodes Previous Episode

Listen for free

Show artwork for RevOps FM

About the Podcast

RevOps FM
Thinking out loud about RevOps and go-to-market strategy.
This podcast is your weekly masterclass on becoming a better revenue operator. We challenge conventional wisdom and dig into what actually works for building predictable revenue at scale.

For show notes and extra resources, visit https://revops.fm/show

Key topics include: marketing technology, sales technology, marketing operations, sales operations, process optimization, team structure, planning, reporting, forecasting, workflow automation, and GTM strategy.

About your host

Profile picture for Justin Norris

Justin Norris

Justin has over 15 years as a marketing, operations, and GTM professional.

He's worked almost exclusively at startups, including a successful exit. As an operations consultant, he's been a trusted partner to numerous SaaS "unicorns" and Fortune 500s.