Apache Burr Ships Stateful AI Agents Without a DSL

Apache Burr (Incubating) just made it credible to build production AI agents without touching YAML, a graph DSL, or a proprietary runtime. The entire framework is pure Python—actions are decorated functions, transitions are tuples, and your state is a plain dictionary you can inspect, persist, and replay.

State as a First-Class Primitive, Not an Afterthought

Most agent frameworks treat state as a hidden global variable you can't snapshot. Burr flips that: every action declares what it reads and writes from a State object, and the Burr UI shows you the exact state after each step. You get built-in persistence to PostgreSQL or custom backends, and you can pause execution for human input at any node. CTO of Peanut Robotics Ashish Ghosh called it "elegant yet comprehensive state management" that let them roll out robots driven by AI decision making.

What Burr Actually Looks Like in Code

Define a chatbot in maybe ten lines:

from burr.core import action, State, ApplicationBuilder

@action(reads=["messages"], writes=["messages"])
def chat(state: State, llm_client) -> State:
 response = llm_client.chat(state["messages"])
 return state.update(messages=[*state["messages"], response])

app = (
 ApplicationBuilder()
 .with_actions(chat)
 .with_transitions(("chat", "chat"))
 .with_state(messages=[])
 .with_tracker("local")
 .build()
)
app.run(halt_after=["chat"], inputs={"llm_client": client})

No LangChain-style chains. No CrewAI agent classes. Just decorated functions and a builder that wires transitions. The same pattern scales to multi-agent systems, state machines, and complex DAGs with branching and parallelism.

Integrates With Your Stack, Doesn't Replace It

Burr works with OpenAI, Anthropic, LangChain, Hamilton, Streamlit, FastAPI, Haystack, Instructor, Pydantic, and PostgreSQL—listed as explicit integrations. No wrappers, no forced abstractions. You keep your LLM client, your vector store, your serving framework. The framework only owns the orchestration and state lifecycle.

What People Who Actually Used It Say

Founder of Watto.ai Ishita: "Using Burr is a no-brainer if you want to build a modular AI application. It is so easy to build with and I especially love their UI which makes debugging a piece of cake." Staff engineer at Paxton AI Matthew Rideout: "No weird esoteric concepts just because it's AI." A Reddit user on r/LocalLlama: "Honestly, take a look at Burr. Thank me later." The tone from practitioners is consistent: this is a framework that gets out of your way and lets you debug and test your agent logic with standard Python tooling.

Burr doesn't claim to be the magic bullet for every AI application. It does something rarer: it gives you a stateful, observable, testable core that doesn't demand a rewrite when your agent logic grows beyond a single loop. That's what makes it worth watching as Apache Incubating project.

Source: Apache Burr: Build reliable AI agents and applications
Domain: burr.apache.org