November 12, 2026

Colt McNealy on LittleHorse

Podcast Chapters

Colt McNealy is a good friend and the founder of LittleHorse, a company working on the problem of business-as-code. I suppose to some degree all business software is "business as code," but as Grady Booch likes to say, the history of software engineering is one of rising levels of abstraction, and Colt has found a useful new level: the business process itself, written in plain Java, Python, Go, or C#, and orchestrated across every system it touches. LittleHorse sponsored this episode, and there are links to the open-source project below if you want to get it running.

We talked about LittleHorse's core abstractions, its open source roots, its relationship to durable execution, and of course how this all interacts with agentic engineering. That was a very cool insight that just dawned on me during this conversation—since Codex, Claude Code, OpenCode, and the like are so good at writing code, the discipline of representing business processes as code makes them natively better at reasoning about business processes themselves. That's somewhere around minute 28 or 29, but hey, listen to the whole thing.

Some important links from the episode:

Full Transcript

00:00 Hey, Tim Berglund here.

00:01 Colt McNealy is a good friend and he's

00:03 the founder of LittleHorse,

00:04 a startup solving the

00:05 problem of business as code.

00:07 But wait, you say, isn't

00:09 that just all business software?

00:10 Well, okay, sure.

00:12 But as Grady Booch has said,

00:13 the history of software engineering is

00:15 one of increasing levels of abstraction.

00:18 And this is so key to

00:20 success in this space.

00:21 And I think a place where Colt

00:23 has really hit the sweet spot.

00:25 We talk about his

00:26 definition of the category,

00:28 how it's different from just durable

00:30 execution and how this all interacts with

00:32 agentic engineering on the

00:34 one hand using coding agents.

00:36 And more importantly, how it supports you

00:38 building your own

00:39 agents in the enterprise.

00:40 It makes some really good insights there.

00:43 Little Horse is the

00:43 sponsor of this episode.

00:45 And if you want to get started, there are

00:46 links in the show notes

00:48 to the open source project

00:49 that will get you up and running.

00:51 Now, let's listen in.

00:52 Hey, Colt, welcome to the show.

00:55 Hey, Tim. Thanks for having me.

00:57 It is always good to talk to you.

00:59 I'm going to start

01:00 with a simple question.

01:02 What's business as code?

01:05 Well, the technical definition is it is

01:07 the practice of using software to express

01:11 and also orchestrate a business process

01:14 at a high level so that you don't have to

01:15 worry about the connections to the

01:17 underlying systems that a

01:19 business process touches,

01:20 which is really valuable because business

01:23 processes live in dozens of systems,

01:25 whether that's microservices, copy

01:27 consumers and producers,

01:28 external SaaS systems

01:29 like Salesforce, SAP, etc.

01:32 And that means the business logic lives

01:35 in the connections between all of them.

01:37 What business as code does is it allows

01:39 you to orchestrate the

01:43 process from a higher level

01:45 without having to worry about all those

01:47 connections and making

01:48 the process reliable.

01:51 Now, I have... That's

01:54 excellent, by the way.

01:55 I love that explanation.

01:57 I know I've asked you in the past what's

02:00 the difference

02:01 between that and what you do

02:04 and durable execution.

02:07 I'm not going to ask you

02:07 that question, at least not yet.

02:10 I think I will ask that in a minute

02:11 because it's relevant.

02:14 What does what you

02:15 guys do at LittleHorse...

02:17 When I just think of the

02:18 phrase "business as code,"

02:20 that's a little bit what we've always

02:21 been doing in writing business software.

02:24 And that's... I've

02:27 long found it fascinating,

02:29 the process of taking business processes,

02:32 which are these mental things that we

02:33 work out in

02:34 cooperation with other people,

02:36 humans communicating and managing

02:38 exceptions and doing

02:39 all that kind of stuff,

02:40 trying to turn that into

02:41 code is actually really hard.

02:42 So my suite of microservices that

02:46 embodies some business process

02:48 and has all the

02:48 integrations, it does all that stuff,

02:51 that's business as code, kind of.

02:53 So what is it that you

02:55 guys do that's not that?

02:58 I mean, how is it different from that?

03:00 So it gives you a higher level of

03:02 abstraction that lets

03:03 engineers write code

03:05 closer to the business process and

03:07 therefore closer to business value.

03:09 So before I started Little Horse,

03:11 I was a software engineer working at a

03:13 real estate company.

03:14 And every time we wanted

03:16 to write a business process,

03:18 which, for example, might have been

03:19 scheduling an open house

03:20 or inspection or getting

03:22 approval for a mortgage,

03:25 we ended up having to touch dozens of

03:27 different microservices

03:28 and external SaaS systems.

03:29 So we'd have to reconfigure SaaS systems,

03:32 customize them a

03:32 little bit to our process,

03:34 and build a bunch of

03:35 different microservices.

03:36 What business as code does is it lets you

03:39 put all of that logic

03:40 for the end-to-end process in one place

03:42 and then orchestrate

03:43 it across everything.

03:44 And you'll be writing

03:46 code that feels very natural,

03:48 very much like Java, Python, Go, C-sharp,

03:50 and it's code that any agent can write.

03:53 But at the other end of it,

03:54 you get a visual

03:55 representation of your business process

03:57 that you can look at

03:57 with your product owner,

03:58 product manager, or business analyst to

04:01 see what's going on.

04:02 Whereas in traditional microservices,

04:04 all you've got is a mess of Kafka topics

04:06 and integrations and RPC

04:08 calls between services,

04:09 and you have no picture of

04:11 how everything works together,

04:12 which means when it comes time to change

04:14 how something works,

04:15 you end up having a very difficult

04:17 cross-team coordination problem.

04:18 And that cross-team coordination,

04:20 especially in larger companies,

04:22 ends up eating the majority of the

04:24 software delivery lifecycle,

04:26 which means that the

04:27 gains we get from AI coding

04:29 are quite modest when you have that

04:31 coordination problem.

04:33 Yes, indeed.

04:35 Okay, and I want to dig

04:37 into the agentic side of this

04:40 a little bit.

04:41 I mean, we'll probably

04:41 spend most of our time

04:42 talking about that actually.

04:43 But I've been puzzling over

04:48 the kind of that question,

04:50 because I know on like

04:52 simple hobby projects

04:54 where the coordination with

04:56 other people is, well, zero,

04:59 the kind of speed up that you can get

05:01 from agentic engineering

05:03 feels infinite.

05:05 It's 10 times, 100 times.

05:07 I could build things that I

05:08 just never would have learned,

05:10 those APIs or that

05:11 platform or whatever in the agent

05:12 will just kind of crap out some stuff.

05:14 And it's great.

05:15 But we don't seem to see that in teams

05:18 building products in the enterprise.

05:21 It keeps building, you

05:22 know, tooling in the enterprise.

05:24 So there are other bottlenecks,

05:25 and it's the cross-team coordination,

05:27 it's just the intra-person, I said

05:30 inter-person coordination.

05:32 Hopefully the intra-person

05:33 coordination is nice and simple.

05:35 We're well-integrated

05:36 persons inside ourselves.

05:37 But talking to people,

05:39 working things out with people

05:41 is still expensive.

05:42 And so you get this agentic speed up in

05:44 this little part of it,

05:45 but all that other stuff is hard.

05:49 And it's kind of funny.

05:52 I mean, this is not the first time you

05:54 and I have talked about LittleHorse

05:56 and even compared it to other

05:58 technologies and all that.

05:59 But that's just dawning on me right now

06:02 that that's a huge

06:04 potential speed up there

06:06 that this now brings that set of human

06:10 coordination problems

06:11 into the purview of

06:12 what an agent might do.

06:14 Am I on to something there?

06:15 Ed, you want to talk more about that?

06:17 You're on to something.

06:19 So what business as code lets you do

06:21 is centralize business

06:23 process logic in one place.

06:25 That is a deployable and

06:26 executable and testable

06:27 and version

06:28 controllable software artifact.

06:30 So in the past--

06:32 And in a programming

06:33 language, it's just Java.

06:35 It's nothing weird here.

06:36 It's a programming language you know.

06:38 A programming language that you know

06:40 and more importantly that Claude knows.

06:42 It's not like a visual tool where you're

06:45 clicking and dragging.

06:47 But it's also the business logic.

06:49 It's not just a

06:50 function that runs durably.

06:52 We'll get to that in a moment, I hope.

06:55 But it's the actual business logic

06:57 in a way that the

06:59 orchestration layer understands it.

07:00 So it's a layer for the

07:03 business process logic.

07:04 And then the microservice

07:06 layer that we've always had

07:08 and event streaming layer is

07:09 kind of a connectivity layer

07:10 that allows you to

07:11 connect to other systems.

07:13 What we've been doing in

07:13 the past is sort of mixing

07:15 business process logic

07:17 with system integration logic

07:19 all in one place.

07:20 So you'll have a

07:20 microservice that does something like

07:23 receive a request that

07:25 is starting the process

07:27 of onboarding a

07:27 customer, put a row in a database

07:30 that represents this process instance of

07:33 onboarding a customer

07:34 and then send a request to

07:36 a third party SaaS service

07:37 that might perform an identity check or

07:39 identity verification.

07:41 And then there'll be

07:41 another webhook handler

07:43 that will receive that

07:46 response from the third party service

07:48 a couple days later and

07:49 then look in the database

07:50 for that record.

07:51 And those two

07:52 endpoints are very disjointed.

07:53 It's very difficult to

07:54 correlate them together.

07:56 Whereas what business as

07:57 code gives you is the ability

08:00 to explicitly specify what should happen

08:03 in an imperative way

08:04 that feels like normal programming.

08:05 And notice I said

08:06 imperative not declarative

08:08 because it just feels very

08:10 much like a scripting language

08:12 when you're writing a

08:14 process in business as code.

08:15 Execute this task, wait for that event.

08:17 If this, go there, else do that.

08:19 Then invoke this agent,

08:20 see what the agent said.

08:21 And depending on the agent's response,

08:23 either go this way, that way or that way.

08:25 Right.

08:27 And the fact that it,

08:28 for whatever it's worth,

08:31 the fact that it's declarative is a

08:34 reason that I believe you.

08:38 Because there's imperative,

08:40 sorry, I said declarative.

08:41 The fact that it is imperative,

08:42 because previous runs at this problem,

08:46 the LittleHorse is not the first time

08:47 somebody's tried to solve this, right?

08:50 We've had all kinds of solutions that

08:53 didn't seem to

08:55 deliver what they promised.

08:57 Often there would be something quirky

08:59 about the way that

09:00 you express the process.

09:02 Like, you know, a certain number of years

09:04 ago, hey, let's do this with XML.

09:06 I mean, there was a

09:07 lot going on at the time

09:08 and people thought XML

09:09 was good for everything.

09:09 And that's terrible.

09:11 But one of our competitors, I won't name,

09:14 believes that XML with

09:16 a pretty GUI over it.

09:17 It's a great way to specify a process.

09:19 I'll put a link in the show notes.

09:23 Yeah. And, you know, no, it's not.

09:27 Because you always end up having to

09:29 reinvent an imperative language.

09:33 Or I suppose if you're so inclined, you

09:34 could reinvent a functional language.

09:36 Whatever. It doesn't matter.

09:37 You're reinventing a language in what you

09:39 had wanted to be declarative

09:44 because the complexities of the process

09:46 just don't admit to being declared.

09:49 I mean, that's probably a

09:50 simple-minded way to put it.

09:51 But that's what I've seen.

09:54 Correct. Actual business processes are,

09:56 you know, I'm a software engineer.

09:57 And I used to think business people were,

09:59 you know, of a lesser

10:01 programming capability

10:03 than us programmers.

10:04 Oh, I know.

10:05 But it turns out that actual business

10:06 processes are quite complex.

10:08 They've got edge cases, failure handling,

10:09 they deal with data.

10:11 And they often can even be

10:14 multi-threaded, they

10:14 require coordination,

10:15 and have race conditions inside them.

10:17 So that's what separates us from, you

10:22 know, sometimes we'll go

10:23 into a big enterprisey account

10:25 and do some selling.

10:26 And they'll ask, well, why are you better

10:29 than some of these, you know,

10:31 business-friendly tools?

10:33 And the answer is that we can actually

10:35 model really important,

10:36 difficult, high throughput,

10:38 mission-critical processes.

10:40 Whereas those visual

10:40 workflow vendors, they can't, right?

10:44 So we're built for software engineers,

10:46 we're built for software developers.

10:48 And the whole point of business as code

10:50 is to help them move up to a

10:51 higher level of abstraction

10:52 and deliver business value faster,

10:54 especially in the age of AI.

10:57 And the other thing about the age of AI

11:00 in the LittleHorse is that

11:03 the business as code layer

11:05 really does a good job of separating the

11:07 concerns of the

11:08 integration and connectivity logic

11:10 from the actual business process.

11:13 So it allows us engineers to work on the

11:15 business process with

11:15 the business stakeholders.

11:18 But, you know, it's not that hard to have

11:19 a Claude connect to a

11:20 database, connect to an API, etc.

11:22 which can be done in the TaskWorker

11:24 layer, underneath the

11:25 business as code layer.

11:27 I suspect we'll want to link

11:29 to something with some diagrams,

11:31 or maybe I can put some diagrams up in

11:34 the video version or something if that's

11:36 helpful for folks watching.

11:36 But you've mentioned that

11:38 separation a couple of times.

11:41 And I don't mind diving into

11:44 the almost API-level thing.

11:46 Can you just help me understand how that

11:48 separation gets done?

11:49 Because it sounds great,

11:50 but how does that work?

11:54 If you're watching on YouTube, what

11:56 you'll see is a diagram of

11:59 the LittleHorse dashboard,

12:00 which shows the actual

12:01 business process logic.

12:04 And you'll notice that there's nothing

12:05 really in this business process logic

12:07 about how you connect to the system.

12:09 So one of those boxes could represent,

12:11 for example, an external SaaS system,

12:13 and another could represent a RPC inside

12:15 a microservice that you wrote that

12:17 connects to your own databases.

12:19 But at the business level, that doesn't

12:21 really matter how you

12:22 connect to those systems.

12:24 What matters is the flow of the business

12:25 process and that's what the

12:27 business's code gives you.

12:28 So you also see on the screen the code

12:31 that generated this business diagram.

12:34 And that code is quite simple and normal

12:39 Java using our LittleHorse DSL.

12:41 And it looks almost the same as Temporal,

12:43 which is durable execution, which is

12:44 literally plain code.

12:47 And you'll notice again here in the code,

12:49 there's also nothing related to how to

12:55 connect to these systems.

12:56 It's just specifying the

12:58 imperative business logic.

12:59 But what happens under the hood is

13:03 LittleHorse will dispatch work to task workers,

13:05 which actually do the real

13:06 connections to other systems.

13:07 And those task workers might be

13:08 microservices or they might just be a

13:11 thin connector layer that

13:12 hits other external APIs.

13:14 And task workers are

13:15 just code that you write.

13:16 You put an annotation on top of an

13:18 existing method in Java where you write a

13:20 new one and annotate it.

13:21 And it allows you to connect

13:22 to all those other systems.

13:23 So little horse will deal with the

13:27 correlation of incoming webhooks that are

13:29 responses from third party systems that

13:31 take a couple of days to get back to you.

13:33 It has built in capabilities to wait for

13:38 human input and is able to

13:41 dispatch work to task workers.

13:42 So the imperative workflow logic at the

13:45 business's code level doesn't actually

13:47 have to worry about how to

13:49 connect to all the systems.

13:51 And we get that very clean separation.

13:53 So if possible, microservices, your

13:55 business process logic is really what Kafka

13:58 Producer is producing which topics

14:00 and what consumers are listening to it

14:02 and how your dead letter queues work.

14:04 Or even worse, it's like the hidden chain

14:08 reaction of four different microservices

14:10 calling each other and

14:11 hitting post endpoints in a row.

14:13 Right. You make that sound fun.

14:16 And your experience and your customers

14:20 and open source user experience agents

14:25 are great at writing like a TaskWorker.

14:27 A TaskWorker contains the kind of stuff

14:28 that is the stuff you'd really like an

14:33 agent to write because it's probably pain

14:35 in the butt integration

14:37 with some other thing.

14:37 But I can create those through whatever

14:41 agentic spec driven factory approach I'm

14:46 doing at the moment.

14:48 No one enjoys going to Oracle NetSuite

14:52 documentation, reading it and then

14:53 figuring out how to craft the perfect

14:55 POST body to hit an endpoint in Java.

14:59 No one enjoys that.

15:00 Zero.

15:01 Claude can do it. And so far he hasn't

15:03 gone on strike yet. Anthropic might call

15:05 that model abuse at some point in the

15:06 future. But until then it's OK.

15:11 Just NetSuite. That's like you. You are

15:14 model abuse. Everything else is fine.

15:17 Well, you know, there's a lot worse than

15:19 NetSuite that we run into. Once you get

15:21 into the enterprise world and you get out

15:22 of the software engineering digital

15:24 native product companies,

15:27 you see some scary things.

15:29 And NetSuite is far from the scariest.

15:30 But it's still not great. Yeah. You do

15:33 see scary things. And I think it's

15:34 important to note that a lot of the world

15:37 runs on those scary things and they're

15:39 not maybe what people like

15:41 you and me find interesting.

15:42 They're not on Hacker News. They're not

15:45 on any leading edge. They're not

15:47 particularly intellectually stimulating.

15:49 But there are real systems that serve

15:51 real people that that have those terrible

15:54 interfaces and be having a system for

15:59 handling them and frankly isolating

16:02 engineers who would like to do cooler

16:03 things from the horrible.

16:05 That's a good thing. Yeah, that's very

16:07 true. There's all sorts of different

16:10 companies out there that have found use

16:12 cases for business-as-code.

16:13 So there's some digital native startups

16:15 doing stuff with blockchain and financial

16:18 transactions using our open source.

16:21 There's other fintech companies. Then

16:24 there's a couple AI startups.

16:28 But towards the other end of the

16:29 spectrum, there's companies that until

16:31 two years ago didn't have any software

16:32 engineers at all. And they're worried

16:34 about managing a fleet of trucks and the

16:36 cost of, you know, SaaS subscriptions.

16:39 So I'm talking about Oracle, NetSuite,

16:41 the big SaaS, and realized that MuleSoft

16:49 and legacy workflow orchestration

16:51 platforms wouldn't give

16:51 them a proper AI strategy.

16:53 And then in the middle of it, there's

16:54 larger institutions that have a really

16:57 capable software engineering team, but

16:59 they've also been

16:59 around for 30, 40, 50 years.

17:01 And because of that, they've got a bunch

17:03 of these old legacy systems that they're

17:05 building around and across.

17:07 So the great thing about business-as-code

17:09 is that a business process is a business

17:10 process, and it doesn't really care

17:12 whether it's orchestrated cutting edge

17:14 microservices and agents or if it's

17:15 orchestrating legacy SaaS.

17:17 That's right. That's right. Or formatting

17:20 some EDI document to put in a file share

17:24 somewhere. I mean, speak of the

17:26 horribleness in certain parts of the

17:28 world. Again, there are

17:29 systems that the world runs on.

17:33 You have mentioned durable execution a

17:35 couple times, and I mean, you've, in

17:40 other conversations and things you've

17:42 written and so forth, you've helped me

17:44 understand the distinction.

17:47 I guess this is not the first time we've

17:49 ever had a conversation about this.

17:51 But I confess I am in the set of people

17:53 who thought that LittleHorse is one of

17:56 the players in the durable execution

17:58 space of which Temporal is far and away

18:02 the biggest and best known.

18:04 And are you a super set of that? Are you

18:08 just a different thing? Give me the full

18:13 version of aren't you

18:15 just durable execution?

18:17 Actually, you are not. A year ago, I

18:21 could look you in the eye and tell you

18:22 the straight face. We're not durable

18:24 execution. We then added a small feature

18:25 to our task worker SDK, which allows for

18:28 a lightweight sort of type of replay.

18:32 I think that's a longer discussion, but

18:35 I'll start with what is durable execution

18:38 and what is Little Horse.

18:40 Give us why everybody cares and why it's

18:43 important. I am not setting this question

18:48 up for, you know, tell us how stupid

18:51 durable execution is. It's an incredibly

18:52 important technology.

18:53 No.

18:54 So why do people care about it right now?

18:57 I wouldn't at all say it's a stupid

18:59 thing, especially because I wrote the

19:01 code to add a lightweight

19:02 version of it into LittleHorse.

19:03 You built it into your

19:03 product. Yeah, right.

19:05 I did that before agents. So I actually

19:06 typed out every single line myself. This

19:10 was in October 2025 before agents were

19:12 really usable for coding.

19:13 Just barely. Yes. Yes. The last few weeks

19:16 of Colt typing code.

19:20 Yeah. Well, then Colt typing code is

19:21 actually not killed by Claude, but rather

19:23 by email, unfortunately.

19:27 And now it just becomes called typing

19:29 markdown blogs and design documents. And

19:32 that's it. This is the way.

19:35 This is the way. So durable execution

19:37 solves a really interesting problem. Max

19:41 Fativ has been working on this problem

19:43 since the early 2000s in AWS.

19:45 And he had a really interesting insight,

19:48 which is that we would write code a lot

19:51 differently if we didn't have to worry

19:52 about restarts and crashes and network

19:56 failures, for example.

19:56 So if you were to take someone straight

20:00 out of CS 101 at any university and then

20:04 tell them to write a program that charges

20:08 a credit card every 30

20:08 days for subscription,

20:09 they probably write a while true loop

20:12 that sleeps 30 days and then makes a

20:14 network call to charge the, you know, do

20:18 some SaaS-y to Stript or something.

20:21 I'd at least use cron, but that one's

20:24 good, too. I mean, you see CS 101, right?

20:28 And yeah, and that's a very reasonable.

20:31 I could totally see why you would do

20:32 that. But that just means you've never

20:34 written code in production. And the real

20:36 reality is that code in production

20:37 doesn't work that way.

20:39 So Max Faviv's insight was, well, there's

20:43 two main problems here. One is, well, the

20:44 actual code that the actual computer

20:47 that's running this program,

20:48 this while loop could crash.

20:50 And the second is what happens if the

20:52 call to Stripe fails, right? That network

20:55 failure, the distributed call fails.

20:57 And durable execution makes it possible

21:01 to write that really simple code and run

21:04 it in production safely, which is

21:05 actually really, really cool.

21:06 And the way they do that is, you know,

21:11 with apologies, we're going

21:12 to get really technical here.

21:14 What they do that is every time there's

21:15 something that takes a long time or is

21:18 not deterministic or creates a side

21:21 effect on an external system, they wrap

21:23 it in the Temporal SDK with something

21:26 like context.executeActivity() is the way

21:28 that Temporal would call it.

21:31 And what it does is when you tell

21:34 Temporal to run this, what they call a

21:35 workflow, which I think is horribly

21:37 named, when you run a Temporal workflow,

21:40 it will literally start a invocation of

21:43 this function that you've written.

21:45 And every time you get to an execute

21:46 activity, what it will do is kind of

21:49 interrupt the flow and it will, the

21:52 Temporal SDK will check with the Temporal

21:54 server and see if you've actually run

21:56 this activity for it.

21:57 And if you haven't, what it does is it

21:58 puts a task on a queue for

21:59 another worker to pick up.

22:01 The other worker does the thing and then

22:03 sends the result back and Temporal

22:04 remembers the result, right?

22:06 So then the SDK comes back to life and

22:09 then returns the result back to your

22:11 code, just normal code keeps running,

22:13 goes to the next

22:13 step, so on and so forth.

22:15 Then there's a crash, right? Temporal

22:18 will detect the crash, long story how it

22:19 does it, and then reschedule the

22:22 execution of the method.

22:25 And then when you get to the context of

22:27 that execute activity, the first one that

22:28 happens, Temporal goes, "Oh wait, I

22:30 already did this four days ago, so I'm

22:32 just going to return the

22:33 result from four days ago."

22:34 And then your function

22:35 continues on as if nothing happened.

22:38 So what Temporal gives you is the ability

22:40 to write code that can withstand crashes

22:41 and network failures without having to

22:42 worry about it, which

22:43 is really, really cool.

22:44 What LittleHorse gives you is the

22:46 ability to write code that orchestrates

22:47 the business process, which is also cool,

22:49 very different problem.

22:51 Within a LittleHorse workflow, sorry,

22:54 business process, there

22:55 are multiple different tasks.

22:56 And our TaskWorker SDK gives you the

22:59 primitives to do durable execution.

23:01 So I could conceivably see a unification

23:05 of LittleHorse and temporal in one use

23:07 case, where perhaps a LittleHorse task

23:09 invokes a Temporal workflow.

23:10 But to be honest, there's a lot of times

23:15 where you have people in Temporal trying

23:18 to model business processes, but there's

23:20 a lot of things missing.

23:22 So the biggest advantage is that in

23:24 LittleHorse, you get a visual

23:26 representation of the process graph that

23:28 shows exactly what's going to

23:29 happen at the business level.

23:31 And you can look at that together with a

23:33 product manager. In Temporal, what you

23:34 get is the history of what happened.

23:36 And it's not necessarily a very human

23:39 readable history because it's just a

23:40 bunch of cached method results, which you

23:43 get in LittleHorse, but you

23:44 also get the business overview.

23:48 And separately, LittleHorse gives you

23:53 events in Apache Kafka in real time as

23:55 your workflow makes progress, which you

23:57 can throw directly into

23:58 Snowflake for analytics.

23:59 You can use them in Open Telemetry to

24:04 monitor the history of your application.

24:07 Other people we've seen use things like

24:11 Kafka Streams or Flink to detect

24:13 anomalies from those events and then

24:15 trigger compensation

24:17 workflows based on those anomalies.

24:20 It's interesting. Best analogy I think of

24:24 off the top of my head. A relational

24:27 database is not a key value store.

24:30 You know, should I use this key value

24:33 store or this relational database? Sounds

24:35 like an incoherent

24:36 question and usually is.

24:38 That's probably somebody who has maybe CS

24:41 level. CS 101 level hasn't thought deeply

24:43 about data storage and retrieval yet.

24:47 It's very possible to I could show you

24:51 right now without using an agent. We

24:54 could make a table that is a primary key

24:55 and a single value, right?

24:57 I can make a key value store in that

24:59 relational database. And if what I really

25:01 need is a key value store, well then yes,

25:04 Postgres and I can't even think of any

25:08 off the top of my head

25:09 that are contemporary.

25:11 Which one? Redis, Roxy? Redis, so Redis.

25:14 Yeah, sure. I can have a data type in

25:15 Redis that is key value.

25:17 Then those are competitive technologies.

25:19 So there are always not always, but in

25:22 the margins between things, there's

25:24 sometimes a degenerate use case of and

25:27 I'll call that key value table in

25:29 Postgres as degenerate use case where

25:31 then it does compete

25:32 with this other thing.

25:32 And so I guess I can understand where the

25:35 confusion comes from because there are

25:37 going to be degenerate uses of I don't

25:41 know which way would be

25:42 degenerate, but maybe like.

25:43 If you work hard enough with a key value

25:45 store, you can turn it into something

25:48 relational-ish. And if you work hard

25:51 enough of durable execution, you can use

25:54 it to sort of

25:54 orchestrate business processes.

25:56 Okay, actually, I now crown my analogy

26:01 much better than what I first thought

26:03 because the reality is you can build a

26:06 relational database out of a key value

26:08 store. It's fine. You can build a

26:09 relational database out of your notebook

26:11 if you work hard enough.

26:13 In that case, you're the API proxy and

26:15 that's that's not a good line of work to

26:17 be in, but you're going to have to write

26:21 a bunch of software on top of that key

26:23 value store to give it relational

26:24 semantics and it's probably not going to

26:26 work real good or real well.

26:29 Likewise, if all you have is durable

26:30 execution, of course, you can do business

26:33 as code. You could build a DSL. You can

26:36 orchestrate processes.

26:37 But who's doing that?

26:38 Well, now you're burning tokens and time

26:41 and and and the bandwidth of your

26:45 organization's energy. If you are not

26:47 yourself typing out the code, you're

26:49 still building all that stuff. And yes,

26:52 if what you want is to orchestrate

26:55 business processes and I don't even like

26:57 that phrase. I don't know if you like

26:58 that phrase, but you're trying to

27:00 translate business

27:00 processes into software.

27:02 Yeesh, why are you taking on all that work?

27:05 The whole purpose of software is to

27:07 automate a business process or to support

27:08 a business process and durable execution

27:12 allows you to support a long-running

27:14 function call

27:16 LittleHorse and business-as-code

27:18 allow you to operate at the

27:18 business process level

27:20 And there's a couple other interesting

27:21 things that the architecture of

27:23 businesses-as-code lets you do and there's

27:27 better type checking and it's really

27:29 built for cross domain workflows where

27:32 perhaps there's one team that owns a

27:34 microservice for payments.

27:35 And then there's another one that's

27:36 shipping and they're strongly typed and

27:39 very easy to invoke cross domain calls.

27:43 So what we've actually seen from talking

27:45 to people who use Temporal and production

27:47 and people who use LittleHorse in production

27:48 is that a LittleHorse workflow

27:49 generally is a lot larger and higher

27:51 level and closer to business value

27:53 because it's so good at cross domain calls.

27:56 Whereas in Temporal a lot of workflows

27:57 really are calling other functions that

28:03 the activities or what we would call

28:05 tasks and LittleHorse in the Temporal

28:08 workflows are actually just local method

28:10 calls that are on the

28:11 same actual microservice.

28:13 Now obviously that's not true. There's a

28:14 lot of people before everyone. There's a

28:16 lot of people who have actual distributed

28:19 workflows that touch many different

28:21 places, but it's a lot easier to build

28:22 those types of workflows and LittleHorse

28:24 because of things like type checking and

28:27 the fact that it's so conducive to

28:28 operating at a higher level.

28:31 We've mentioned agentic engineering a few

28:33 times and I think the thing we have meant

28:36 is the thing that most people mean, which

28:39 is I'm using Claude Code or Codex or in

28:43 deference to my friend and lover of open

28:48 source, maybe Open Code and a locally

28:52 hosted open weight model.

28:54 You know, we're not animals.

28:55 Not quite there yet.

28:56 Not quite there. Yeah, that's that tough.

28:57 So whatever, you know, a coding agent to

29:00 write the software that that a year ago I

29:02 would have written by hand. But now I

29:04 prompt through whatever process. So

29:06 mostly when we say agent without

29:10 qualifying it or being

29:11 specific, we mean that kind of agent.

29:13 But of course in the enterprise also we

29:16 as a community of developers are being

29:18 called upon to build agents that do

29:20 things. I'll just maybe this is a little

29:23 tendentious, but I'll say that carry out

29:26 business processes inside the enterprise.

29:29 So could you talk about that?

29:31 You know, I've spent some time online

29:36 trying to get people to think it's not

29:38 just Claude Code. You have to build your

29:40 own agents. Think about the problems you

29:41 have to solve now. You know,

29:42 where do you guys fit into that?

29:46 The enterprise developer building an

29:49 agent, taking some kind of unstructured

29:51 input and doing a business thing.

29:54 That's actually where we really found our

29:55 stride as a company. So you do a great

29:58 job by drawing a distinction between I'm

30:00 using an agent on my laptop to write code

30:02 and I've got a business

30:03 process out there that uses agents.

30:04 So one of the big things we've actually

30:07 had to explain and differentiate is that

30:12 an agent is actually not an orchestrator

30:14 You can't just hand the business

30:15 process to an agent and

30:16 say, well, now it's automated.

30:17 But that doesn't quite work that way. And

30:20 a lot of things break down really quick

30:22 when you treat Claude as your integration

30:24 platform and your orchestrator. First is

30:26 the determinism because if it gets the

30:29 answer right, mabye 99.99% of the time

30:31 not right enough for the IRS.

30:34 And obviously that brings in compliance.

30:36 It's a second problem. Third problem

30:38 becomes durability, which we were talking

30:40 about earlier. And the fourth problem is

30:43 processes that need

30:43 to wait for something.

30:44 So it's very difficult to get Claude

30:46 to wait for a webhook to come back three

30:48 days later. Yeah, not going to happen.

30:53 All those things are basically can be

30:57 summed up by saying an agent's not an

30:59 orchestration layer and LittleHorse

31:01 businesses-as-code is an

31:02 orchestration layer.

31:03 And the way we think about it is the real

31:05 goal of software is to support for

31:07 automate business processes. The business

31:09 process consists of

31:10 tasks and waiting for events.

31:12 So where do agents fit into all of this?

31:15 An agent can do a task. So what we say,

31:19 what we often say is a lot of the

31:21 business processes we work with have

31:22 multiple agents, not just one. And they

31:24 also have deterministic steps, such as

31:27 telling the authorities that there was an

31:29 order placed for tax purposes or at least

31:31 notifying your ERP about it.

31:34 And those are things that you don't want

31:35 to be burning tokens to figure out every

31:37 time you don't want to use Claude as an

31:40 integration layer. You should

31:42 deterministic codify things that are

31:44 deterministic. And then the parts of the

31:46 process that five years ago were not

31:48 possible to automate, such as extracting

31:50 unstructured data or extracting structure

31:53 from an email or drafting

31:57 a response to a customer.

32:00 Discovering intent from unstructured

32:03 natural language input. That used to be

32:06 super duper hard. And now, the way we say

32:10 this, if you look at a LittleHorse

32:11 workflow diagram on the dashboard, maybe

32:13 a bunch of things that used to have the

32:15 blue human task box now can be system

32:18 tasks done by agents. But the workload is

32:20 generally relatively similar.

32:24 That is an excellent insight. So and the

32:30 agent, the harness that I am building as

32:32 an enterprise developer to carry out this

32:36 process, I feel like let me give my

32:40 definition of agent, right? It's a

32:42 program that takes probably unstructured

32:45 input and causes side effects in the

32:48 world. It like does, it has to call a tool.

32:50 If it's an agent, it's

32:51 got to go do something.

32:53 We say call a tool that's kind of coding

32:54 language or coding agent language, but it

32:58 does stuff and it takes unstructured

33:00 input and it uses an LLM to interpret

33:02 the unstructured input. Okay. If it's not

33:04 that it's not an agent, it's it's maybe

33:08 business-as-code. Maybe it's some kind of

33:10 process managed by LittleHorse, but

33:12 qualify as an agent. There's got to be an

33:14 LLM doing an LLM-y thing in there.

33:16 And that diagram that you just described

33:19 that is using the right

33:21 word to say process. Sure.

33:25 Old, you know, curmudgeonly competitors.

33:29 I like the word process.

33:32 Obviously don't confuse it with a process

33:35 that's built on top of XML. No, no. In

33:38 fact, I'm going to I'm going to bleep out

33:40 you having said XML.

33:42 I might I might do that for all the XMLs

33:44 that we said. Wonderful. Yes.

33:49 That that that process, the code that

33:51 executes that if there's an LLM being

33:54 called in there, one might call that an

33:56 agent now. I don't think that's a

33:58 stretch of the terminology.

34:01 And the year insight that those blue

34:03 boxes that used to be a human has to

34:05 figure this out. Now we've got LLMs

34:08 that do a good job at

34:09 some kinds of those things.

34:11 And the process itself isn't reduced to a

34:16 prompt and the right tools specified in

34:22 the API call for the

34:24 right things to happen.

34:25 In the most successful LittleHorse

34:28 implementations, a lot of processes are

34:29 not triggered by someone clicking on a

34:31 screen or typing into a chat bot and

34:33 saying, go do this, but rather by an

34:34 event happening somewhere.

34:37 OK, so when you when you think of Claude

34:40 as an orchestrator, all what who's going

34:42 to who's going to pop the clock, right?

34:43 And if you've still got a human sitting

34:45 there telling Claude to go copy a lead

34:47 from, you know, a hub spot into the ERP

34:51 system or something after invoices and

34:52 file, that's not really automation.

34:54 That's just moving the copy and paste job

34:57 to Claude instead of a human. Yeah, yeah.

35:01 I'm going to be thinking

35:04 about that a little bit.

35:05 You've probably even written that before.

35:07 It's just a really good insight. It helps

35:09 me make sense of the the whole agent and

35:13 LittleHorse situation. How about you

35:16 mentioned Kafka? Is

35:18 Kafka like an integral part?

35:20 How does LittleHorse interact with

35:21 Kafka? What's the situation there? We

35:24 interact with Kafka for two ways and I

35:26 either have months where I'll talk about

35:29 it all the time and I have months where I

35:30 try to hide it because

35:31 it's very polarizing.

35:32 But Kafka, we basically built speaking of

35:36 key value stores, we took RocksDB and Kafka

35:39 and Kafka streams, put them together and

35:41 built our own store retention for LittleHorse

35:45 that was hyper, hyper optimized for

35:47 our workflow engine, which gives us a lot

35:49 of throughput and scalability.

35:51 Because if you look at the query patterns

35:53 of a workflow engine, there's a lot of

35:54 back and forth when a task result

35:57 happens. You have to look up the

35:59 workflow, you have to look up the

36:00 history, decide what's next, save a bunch

36:02 of things, which is a lot of them are

36:03 called back and forth from the database,

36:05 which you don't want.

36:05 So by using Kafka Streams and RocksDB and

36:08 producer batching, etc, long story short,

36:12 we have built an internal data store that

36:14 is hyper optimized and allows us to get a

36:15 lot more throughput than some of our

36:16 competitors and we'll put out a benchmark

36:18 soon and maybe you

36:19 can share notes with it.

36:23 But long story short, Kafka is number

36:27 one, an implementation detail of LittleHorse

36:28 We use it as the commit log for

36:30 the distributed database that we have.

36:32 Number two, Kafka is related to LittleHorse

36:37 in a couple of ways. We've got a

36:38 bunch of Kafka connectors that trigger

36:40 workflows or post events or post

36:41 correlated events to run our workflows,

36:44 which allow you to respond to events in

36:46 your Kafka ecosystem.

36:48 And obviously with Kafka Connect, then

36:50 that means by extension, you can respond

36:51 to events in whatever streaming platform

36:53 you've got or even some of your legacy

36:57 SaaS systems that for a web hooks, they

36:59 can be caught by some big way, which

37:01 throws them into Kafka and then away you

37:03 go with LittleHorse events.

37:06 And the other probably most interesting

37:07 way that we work with Kafka is the output

37:11 topic, which produces events into Kafka

37:13 in real time as your workflow hits

37:16 meaningful business milestones and that

37:18 can turn into business insights.

37:19 It can turn into infrastructure

37:20 observability and can also turn into real

37:23 time anomaly detection and response. So

37:27 we tell our customers, you don't need to

37:28 know that Kafka is

37:29 there, but it is there.

37:30 If you notice there, it gives you a ton

37:33 of rich integrations.

37:36 What do you hope LittleHorse is able to

37:39 accomplish in a completed version of the

37:42 vision? What's the future look like?

37:46 So the open source, the vision for that is

37:50 that in five years, because going back to

37:58 the analogy for relational databases and

38:02 key value source, in five years, no one's

38:04 using Temporal ever just using the

38:05 LittleHorse open source to orchestrate the

38:07 business processes and not dealing with

38:09 the effort it takes to create a business

38:11 layer on top of Temporal.

38:14 But LittleHorse can go down and up the

38:16 stack, whereas Temporal is more of a low

38:17 level orchestration engine. So for the

38:20 open source, that's our goal and we're

38:22 going to build it towards that.

38:24 And for the commercial platform, we're

38:26 building a bunch of connectors and low

38:27 code integrations and working on, well,

38:31 haven't yet released.

38:32 But hopefully in a year or so, we'll have

38:34 a really good runtime platform that makes

38:36 it easy for enterprises to deploy and

38:40 monitor and maintain their own business

38:42 code solutions without having to worry

38:44 about the hassle of Kubernetes or

38:46 anything else like that.

38:50 My guest today has been Colt McNealy.

38:52 Colt, thanks for being here with me.

38:54 Thank you, Tim. Appreciate it.

38:55 All right, you stop recording.

An agent is actually not an orchestrator. You can't just hand the business process to an agent and say, well, now it's automated. — Colt McNealy

No one enjoys going to Oracle NetSuite documentation, reading it and then figuring out how to craft the perfect POST body to hit an endpoint in Java. — Colt McNealy

That's not really automation. That's just moving the copy and paste job to Claude instead of a human. — Colt McNealy

About Colt

Colt McNealy is the founder and CEO of LittleHorse, the business-as-code company. LittleHorse represents complex business processes in code, so that they can be tested, version-controlled, and durably orchestrated across diverse systems. When he is not being a CEO, Colt also enjoys playing golf, reading, cooking, and being a brother and a husband.

Comments

No comments yet. Be the first!