Retrieved article excerpt
Open article · Retrieved 2026-09-23T16:27:39.759427+00:00
# LittleHorse Open-Source
[littlehorse.io](https://littlehorse.io/)
[littlehorse.io/learn](https://littlehorse.io/docs/getting-started/quickstart)
[littlehorse.io/docs](https://littlehorse.io/docs)
[LittleHorse](https://littlehorse.io) is the pioneer of the [Business-as-Code](https://littlehorse.io/blog/business-as-code) approach to codifying and orchestrating processes across multiple systems. Built with love by developers, for developers!
Business-as-Code allows software engineers to write code in a language of their choice (Java, Python, Go, C#, Typescript) while operating at a higher level of abstraction: the business process. This increases the importance of software engineers by allowing them to speak the language of business value rather than being preoccuppied with glue code.
LittleHorse maintains an open-source platform for Business-as-Code, based on the [LittleHorse Server](https://github.com/littlehorse-enterprises/littlehorse), which is our distributed & fault-tolerant runtime for Business-as-Code. Our open-source platform is lightweight, easy to deploy, and integrates with programming languages and deployment architectures (eg. Kubernetes, Docker, ECS) that you already have.
LittleHorse Enterprises also provides an enterprise platform for Business-as-Code: the [Saddle Command Center](https://littlehorse.io/products/saddle-command-center), which includes pre-built task workers, connectors, integrations, and low-code GUIs to accelerate Business-as-Code deployments at an enterprise.
## Get Started
`📖 START HERE: Quickstarts`
`GitHub lh-developer-hub`
`📖 Documentation`
`💬 Slack Community`
### Our Open Platform
The following repositories contain the most important components of our open-source platform (and they are also crucial components of our *Saddle Command Center* product).
`GitHub CORE: littlehorse`
`GitHub lh-agent-connector`
`GitHub lh-quarkus`
`GitHub lh-kafka-connect`
`GitHub lh-user-tasks-bridge`
- `littlehorse` contains the code for the LittleHorse Server, which is the core of our Business-as-Code platform.
- `lh-agent-connector` contains a pre-built Task Worker that uses LangChain to implement the [Decision Worker Pattern](https://littlehorse.io/blog/decision-workers).
- `lh-quarkus` contains Quarkus extensions to make it really easy to write LittleHorse applications in Java.
- `lh-kafka-connect` contains Connectors for Apache Kafka Connect to start `WfRun`s and post `ExternalEvent`s in the LittleHorse Server.
- `lh-user-tasks-bridge` connects your OIDC provider to the LittleHorse Server's [User Tasks](https://littlehorse.io/docs/server/concepts/user-tasks) capability, mapping user identities to assigned tasks.
## What Is Business-as-Code?
**Business-as-Code** is the practice of using code to define and orchestrate processes across multiple systems and people. Software engineers use Business-as-Code to orchestrate flows involving external SaaS APIs, microservices, event queues, agents, and human steps.
Business-as-Code explicitly specifies process logic at the business level from the top-down rather than letting processes emerge bottom-up via brittle point-to-point connections between systems. This approach is useful both for high-speed microservice flows, IoT integration, agent orchestration, and back-office automation alike.
[LH](https://github.com/littlehorse-enterprises/.github/blob/master/assets/wfRun.png)
☝️ This picture shows a running instance (`WfRun`) for the process (`WfSpec`) defined by this code 👇
```
public void quickstartWf(WorkflowThread wf) {
WfRunVariable fullName = wf.declareStr("full-name").searchable().required();
WfRunVariable email = wf.declareStr("email").searchable().required();
// Social Security Numbers are sensitive, so we mask the variable with `.masked()`.
WfRunVariable ssn = wf.declareInt("ssn").masked().required();
WfRunVariable identityVerified = wf.declareBool("identity-verified").searchable();
wf.execute(VERIFY_IDENTITY_TASK, fullName, email, ssn).withRetries(3);
NodeOutput identityVerificationResult = wf.waitForEvent(IDENTITY_VERIFIED_EVENT)
.timeout(60 * 5) // 5 minute timeout
.withCorrelationId(email)
.registeredAs(Boolean.class);
wf.handleError(identityVerificationResult, LHErrorType.TIMEOUT, handler -> {
handler.execute(NOTIFY_CUSTOMER_NOT_VERIFIED_TASK, fullName, email);
handler.fail("customer-not-verified", "Unable to verify customer identity in time.");
});
identityVerified.assign(identityVerificationResult);
wf.doIf(identityVerified.isEqualTo(true), ifBody -> {
ifBody.execute(NOTIFY_CUSTOMER_VERIFIED_TASK, fullName, email);
})
.doElse(elseBody -> {
elseBody.execute(NOTIFY_CUSTOMER_NOT_VERIFIED_TASK, fullName, email);
});
}
```
As you can see, the code above closely mirrors our example KYC business process. LittleHorse handles retries, timeouts, and orchestration across services for you, allowing your `WfSpec` to focus just on what matters to the business. Task workers handle integrations with external systems and databases.
The process of running workflows in LittleHorse is simple:
- Define tasks which are units of work that can be used in a process, and implement programs that execute those tasks.
- Define your workflows and tell the workflow engine about it
- Run the workflow
- The workflow engine ensures that your process gets executed correctly.
## FAQ
- [How is Business-as-Code different from Infrastructure-as-Code?](https://github.com/littlehorse-enterprises#how-is-business-as-code-different-from-infrastructure-as-code)
- [How is Business-as-Code different from Durable Execution like Restate, DBOS, or Temporal?](https://github.com/littlehorse-enterprises#how-is-business-as-code-different-from-durable-execution-like-restate-dbos-or-temporal)
- [Does LittleHorse fit in with Kafka?](https://github.com/littlehorse-enterprises#does-littlehorse-fit-in-with-kafka)
- [Do I need Business-as-Code if I don't read the code anymore?](https://github.com/littlehorse-enterprises#do-i-need-business-as-code-if-i-dont-read-the-code-anymore)
- [How does Business-as-Code help me orchestrate agents?](https://github.com/littlehorse-enterprises#how-does-business-as-code-help-me-orchestrate-agents)
- [How does Business-as-Code help manage the mountain of new code built by agents?](https://github.com/littlehorse-enterprises#how-does-business-as-code-help-manage-the-mountain-of-new-code-built-by-agents)
- [Is LittleHorse fast? Does it scale?](https://github.com/littlehorse-enterprises#is-littlehorse-fast-does-it-scale)
- [How do I deploy LittleHorse?](https://github.com/littlehorse-enterprises#how-do-i-deploy-littlehorse)
- [If LittleHorse is Open-Source, how do you make money?](https://github.com/littlehorse-enterprises#if-littlehorse-is-open-source-how-do-you-make-money)
### How is Business-as-Code different from Infrastructure-as-Code?
Infrastructure-as-Code brings governance, observability, version-control, and automation to devops, which is the process of provisioning infrastructure and deploying applications. Business-as-Code provides the same exact benefits (!!) but in a different space: business process orchestration.
### How is Business-as-Code different from Durable Execution like Restate, DBOS, or Temporal?
Business-as-Code operates at a higher level of abstraction than Durable Execution. In Durable Execution, side effects of your functions & method calls (including remote task executions on different workers) are recorded by the Durable Execution engine. In case your function fails, it can be retried, and side effects are replayed.
In contrast, in Business-as-Code, LittleHorse understands your business process. You first write code that specifies the process, which is then compiled into a computational graph (a `WfSpec`) that LittleHorse understands. There's no function that gets replayed, because the orchestration is handled by the LittleHorse Server. This enables several key features:
- Visualization of your process graph.
- Sending real-time events into Apache Kafka as your workflow executes.
- Easier
Our founder, Colt McNealy, wrote a detailed blog comparing Business-as-Code and durable execution. Read it [on our website](https://littlehorse.io/blog/beyond-durable-execution).
### Does LittleHorse fit in with Kafka?
LittleHorse is tightly integrated with the Apache Kafka ecosystem. The LittleHorse Server uses Kafka (or any Kafka-compatible system) as its internal durable commit log. If you already have a Kafka service, then deploying LittleHorse is easy!
We also have a two-way integration with Kafka:
1. The LittleHorse Server produces events to Kafka in real-time as your workflow progresses, allowing you to turn workflows into business insights.
2. Our [Kafka Connectors](https://github.com/littlehorse-enterprises/lh-kafka-connect) allow you to trigger workflows and post events to LittleHorse from Kafka topics.
Kafka is great for event streaming and messaging, but it's not the best solution for reliably executing multi-step flows across multiple services: sometimes, it's hard to manage business processes when the logic is scattered across different consumers. That's what Business-as-Code fixes!
### Do I need Business-as-Code if I don't read the code anymore?
You don't necessarily need to read the code, but you absolutely do need to understand your systems. Business-as-Code actually makes it easier to understand the code that Claude writes. When Claude writes a `WfSpec`, the LittleHorse dashboard *deterministically* visualizes the exact business logic written in that `WfSpec`. You can easily (visually) verify the way all of your sub-systems are composed together into a workflow rater than having to chase down the connection logic through opaque code and queue consumers.
### How does Business-as-Code help me orchestrate agents?
Using agents to write code is one thing, but putting them into user-facing workloads is more difficult because there is no live verification step. Doing this requires properly connecting the agent into workflows, auditing what the agent does, and preventing the model from doing the "wrong thing". Business-as-Code helps you create these guardrails:
- Invoke the Agent as a Task as part of a larger workflow
- Codify the deterministic parts of the workflow that happen before and after the fuzzy logic which is done by the agent
- Audit every tool call as a Checkpoint in a TaskRun
Our founder, Colt McNealy, wrote a blog about how companies use LittleHorse to deploy agents in this way: [Decision Workers](https://littlehorse.io/blog/decision-workers).
You might also want to check out our open-source [Agent Worker](https://github.com/littlehorse-enterprises/lh-agent-connector), which was purpose built for these workflows.
### How does Business-as-Code help manage the mountain of new code built by agents?
Coding agents have *massively* sped up the creation of new code. More and more business processes will be automated, which means more and more integrations and microservices will be deployed. This poses two problems:
1. It's harder to understand all of the new code when we don't write it ourselves.
2. With more and more integrations, it's harder and harder (for both humans and agents) to write processes across
Business-as-Code solves these two problems by **visualizing the end-to-end process** in the LittleHorse Dashboard, and also **handling the orchestration across all of our systems.**
Business-as-Code also helps software engineers move up the stack and become more valuable to their business. The future is uncertain, but we engineers solve problems and we adapt! Business-as-Code is one way that we can get ready for the next wave of software development.
### Is LittleHorse fast? Does it scale?
LittleHorse is fast: depending on the configuration of the LittleHorse Server, latency between two steps in a workflow is