Apache Burr (incubating) is an Apache-licensed Python framework for building applications that make decisions — chatbots, agents, and simulations — which you monitor, trace, persist, and execute on your own infrastructure.

What it is

Apache Burr lives in the AI and machine learning infrastructure space as an LLMOps and MLOps tool, and it models an application as a state machine, meaning a graph or flowchart of actions joined by transitions. The building blocks are plain Python: functions decorated with @action that declare which state keys they read and write, assembled through an ApplicationBuilder with with_actions, with_transitions, with_state, and with_entrypoint, then executed with app.run. The project ships three pieces: a dependency-free, low-abstraction Python library for building and managing state machines, a UI that shows execution telemetry for introspection and debugging, and a set of integrations for persisting state, connecting to telemetry, and wiring in other systems. Burr is explicitly LLM-friendly without being LLM-dependent — the README notes you can query a model however you like inside an action, or not use one at all.

The concrete problem Burr solves is the plumbing that surrounds any stateful, decision-heavy application: managing state, tracking complex decisions, adding human feedback, and enforcing an idempotent, self-persisting workflow. Rather than hand-rolling state handling, trace logging, and save-and-load logic around model calls, an application declares its actions and transitions and lets Burr record what happened and where the state went. Pluggable persisters, such as the ones for memory, save and load application state, so a run can be inspected or resumed instead of reconstructed from log files.

Key capabilities

• State machine execution model built from @action functions that declare reads and writes over State, wired together with ApplicationBuilder and with_transitions.
• Partial and resumable runs through app.run(halt_after=["ai_response"], inputs={"prompt": "..."}), which stops at a named action and returns the resulting state.
• Telemetry UI started with the burr command, loaded with default data and a demo chat application under the Demos sidebar so execution can be watched changing in real time.
• Real-time tracking, monitoring, and tracing of a running system through that UI, aimed at introspection and debugging.
• Pluggable persisters, including a memory persister, for saving and loading application state.
• Framework-agnostic LLM integration: the README states Burr integrates with your favorite frameworks and that the library does not care how LLMs are called.
• Dependency-free core library, with an optional CLI distributed through the [start], [learn], and [cli] extras that requires Python 3.10+, while core usage remains compatible with Python 3.9.

Who uses it and how

• Teams building chatbots and agents that need to see what a system actually did, using the telemetry UI for tracing instead of inferring behavior after the fact.
• Workflows that require human feedback in the loop, modeled as an explicit state or transition rather than an out-of-band prompt.
• Applications that must be idempotent and self-persisting, where a persister reloads state so a run continues rather than restarting.
• LLM application developers who already use another framework and want Burr for state, tracing, and persistence without replacing their existing stack.
• Simulation and graph-shaped workloads, reflected in the project topics for DAGs, graphs, state management, LLMOps, and MLOps.
• Individual developers evaluating the framework through the bundled examples, such as examples/hello-world-counter run with python application.py.

Getting started

Install the burr package from PyPI, adding the optional [start], [learn], or [cli] extras when the CLI is wanted, and run the burr command to open the telemetry UI. To run the counter example, clone github.com/apache/burr, change into burr/examples/hello-world-counter, and run python application.py.

How it compares

The facts provided name no comparable or paid products that Apache Burr replaces, so it stands alone in this registry on that axis. No competing self-hosted alternative, hosted service, or licence comparison is documented here to contrast against.

When to use it — and when not to

A self-hoster must run the telemetry UI process and choose and operate a persister if state should survive between runs, and the demo chatbot only chats when the OPENAI_API_KEY environment variable is set, although the UI still demonstrates the flow without one. The optional CLI extras raise the floor to Python 3.10+, and the project carries the Apache incubating label, with 99 open issues at the time of the supplied data. Anyone wanting a fully managed hosted service, a non-Python stack, or a framework that dictates how models are called should look elsewhere, because Burr deliberately supplies the state, tracing, and persistence layer and leaves the model call to the developer.

burr

git clone https://github.com/apache/burr && cd burr/examples/hello-world-counter
python application.py

from burr.core import action, State, ApplicationBuilder

@action(reads=[], writes=["prompt", "chat_history"])
def human_input(state: State, prompt: str) -> State:
    # your code -- write what you want here, for example
    chat_item = {"role" : "user", "content" : prompt}
    return state.update(prompt=prompt).append(chat_history=chat_item)

@action(reads=["chat_history"], writes=["response", "chat_history"])
def ai_response(state: State) -> State:
    # query the LLM however you want (or don't use an LLM, up to you...)
    response = _query_llm(state["chat_history"]) # Burr doesn't care how you use LLMs!
    chat_item = {"role" : "system", "content" : response}
    return state.update(response=response).append(chat_history=chat_item)

app = (
    ApplicationBuilder()
    .with_actions(human_input, ai_response)
    .with_transitions(
        ("human_input", "ai_response"),
        ("ai_response", "human_input")
    ).with_state(chat_history=[])
    .with_entrypoint("human_input")
    .build()
)
*_, state = app.run(halt_after=["ai_response"], inputs={"prompt": "Who was Aaron Burr, sir?"})
print("answer:", app.state["response"])