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:
- Beyond Durable Execution: Business as Code (Colt's definitive explanation to date of business-as-code)
- Getting started with LittleHorse
- Getting started with open source LittleHorse Server
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.
- LittleHorse
- LittleHorse on GitHub, the open-source server
Comments
No comments yet. Be the first!