Apache Burr vs LangGraph vs CrewAI: Choosing an AI Agent Framework in 2026

Apache Burr landed on the front page of Hacker News today with 142 points. The headline - "Build reliable AI agents and applications" - is deliberately unsexy, and that is part of the point. While LangGraph and CrewAI have dominated the agent framework conversation for the past 18 months, Burr has been quietly maturing under the Apache Software Foundation's incubator, accumulating 2,100 GitHub stars and north of 400,000 PyPI downloads with almost no hype.

The question developers are actually asking is not whether Burr is interesting. It is whether you should change what you are building toward. This post gives you the comparison that makes that decision straightforward.

Last updated: June 10, 2026

What Apache Burr Actually Is

Burr is a Python library for building stateful, observable AI applications by modeling them as explicit state machines. You define actions (Python functions decorated with @action), declare what state keys each action reads and writes, specify transitions between actions, and hand it to an ApplicationBuilder. The runtime handles execution, persistence, and observability from there.

The core API looks like this:

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})

The reads and writes declarations are not just documentation. They are enforced contracts. Burr uses them to track every state transition, build a full execution graph, and power the Burr UI - a real-time debugger that shows state changes as they happen. This is not a nice-to-have; it is the design center of the framework.

"Reliable" in Burr's vocabulary means three concrete things: you can always see what state your application was in, you can replay any past execution from any point, and you can pause and resume mid-run (including for human-in-the-loop approval steps). The framework achieves this through first-class persistence backends - local, database, or custom - that checkpoint after every action.

The Apache incubation status is worth understanding. It means Burr has gone through ASF's community-over-code governance process: IP clearance, a Project Management Committee, public mailing lists, and a release process built for longevity rather than velocity. This is a different risk profile than VC-backed open source.

LangGraph

LangGraph (from LangChain) models your application as a directed graph of nodes. Each node is a function; edges define control flow. State flows through the graph as a typed TypedDict or Pydantic model. The framework supports cycles (enabling agentic loops), conditional edges, and checkpointing via a persistence layer called a "checkpointer."

LangGraph's main strengths are its integration with the LangChain ecosystem (tools, memory, retrieval) and the LangSmith observability platform. If you are already using LangChain, adding LangGraph costs almost nothing in onboarding time. The graph abstraction is also genuinely powerful for complex multi-step workflows where different paths through the graph depend on runtime conditions.

The tradeoffs: LangGraph is a commercial open-source play by LangChain Inc., which has pivoted its product direction several times. The API surface has changed substantially across versions. Production users report that the abstraction starts to feel leaky when you need precise control over state mutations or want to unit-test individual nodes in isolation.

CrewAI

CrewAI takes a fundamentally different angle. Instead of state machines or graphs, it models work as a team of role-based agents: a researcher, a writer, a critic. Each agent has a goal, a set of tools, and a memory. You define tasks and assign them to agents or let a "manager" agent orchestrate dynamically.

CrewAI is the right framework if your problem maps naturally to parallel specialization - multiple agents working different angles of a problem simultaneously. Its multi-agent support is built-in and relatively easy to configure. The @agent and @task decorators make a simple crew readable in about 30 lines of Python.

The tradeoffs: because agents are autonomous role-players, determinism is harder to enforce. If you need tight control over exactly what happens at each step, CrewAI works against you. Observability is weaker than Burr or LangGraph unless you add LangSmith or a custom callback. CrewAI is backed by venture capital and has grown fast, which means the API has moved quickly and community-reported bugs sometimes lag fixes.

Head-to-Head Comparison

When Each Framework Wins

Choose Burr when you need production reliability and auditability. If you are building an agent that touches money, healthcare, legal documents, or any domain where you need to explain exactly what happened and replay it, Burr's state machine model gives you that out of the box. The Apache governance also matters if you are evaluating frameworks for an enterprise that cares about long-term vendor risk. The .with_tracker("local") call is genuinely one line.

Choose LangGraph when you are deep in the LangChain ecosystem already and your workflow has complex conditional branching. If you have existing LangChain tools, retrievers, and memory objects, the migration cost to any other framework is real. LangGraph's conditional edges handle "call the tool, check the output, decide what to do next" loops well.

Choose CrewAI when your problem is naturally parallel and role-shaped. Research tasks, content pipelines, competitive analysis - anything where multiple specialized agents working simultaneously gets you to the answer faster than a linear pipeline is a good CrewAI fit. It is also the fastest framework to prototype in if you are demoing to non-technical stakeholders who respond well to the agent-as-team metaphor.

When You Should Skip Frameworks Entirely

This is worth saying directly: for a large class of AI applications, you do not need any of these frameworks.

If your agent is: one or two tools, a loop that runs until the model says done, and a single state object you manage yourself - a plain Python loop against the model API is almost certainly the right choice. It is easier to test, easier to debug, and has zero framework-upgrade risk.

messages = []
while True:
    response = client.messages.create(model="...", messages=messages, tools=tools)
    if response.stop_reason == "end_turn":
        break
    # handle tool calls, append to messages, continue

Frameworks add value at the point where you need persistence across process restarts, replay/debugging tooling, human-in-the-loop checkpoints, or enough workflow complexity that the control flow itself becomes a maintenance burden. Below that threshold, they add abstraction cost without benefit.

Burr is actually honest about this in its own documentation. The same is true for good LangGraph use - the graph model starts earning its keep around three or more nodes with branching logic.

The Apache Factor

It is worth spending a paragraph on what Apache incubation means in practice, because it changes the risk calculus for some teams.

The ASF's model is designed to outlast any individual company or contributor. Projects graduate from incubation when they demonstrate a self-sustaining community with diverse committers, a working release process, and adherence to Apache norms around IP and licensing. This is categorically different from "we open-sourced our product under MIT." LangChain Inc. and CrewAI Inc. could pivot, be acquired, or change their licensing. An ASF project's governance is structurally resistant to those outcomes. For teams building on frameworks with a 5-year horizon, that matters.

Burr is still in incubation, which means it has not finished that process yet. But the trajectory is clear.

The Bottom Line

Burr is the framework to reach for when reliability and auditability are the primary constraints. LangGraph wins when you are already in the LangChain ecosystem and need complex graph-based control flow. CrewAI wins when your problem is parallel and role-shaped and you want to move fast.

And for simple agents - one loop, two tools, a state dict - write the loop. Any of these frameworks will slow you down more than they help until the complexity actually justifies them.

FAQ

What is Apache Burr used for?

Apache Burr is used for building stateful AI agents and applications that need to be reliable, resumable, and observable. Common use cases include multi-step LLM pipelines, chatbots with persistent state, human-in-the-loop approval workflows, and any agent application where you need to debug, replay, or audit execution history.

Is Apache Burr production-ready?

Burr is still in the Apache incubator, but it has over 400,000 PyPI downloads and an active community. The core state machine and persistence model are stable. As with any incubating project, the API may evolve before graduation. For production use, pin your version and monitor the release changelog.

What is the difference between LangGraph and Apache Burr?

LangGraph models workflows as directed graphs of nodes; Burr models them as explicit state machines with declared read/write contracts per action. Both support cycles, persistence, and observability, but Burr's observability is built-in and framework-native (the Burr UI), while LangGraph's relies on LangSmith (a paid external service). LangGraph integrates more tightly with the LangChain tool ecosystem; Burr is LLM-provider-agnostic with no opinion on which SDK you use.

How does Apache Burr handle state?

Burr's State object is an immutable, serializable dictionary. Every action declares which keys it reads and which it writes via the @action(reads=[...], writes=[...]) decorator. This enforces clean state boundaries and enables the framework to automatically persist, replay, and trace every state transition. You update state by returning a new state from your action using state.update(...) or state.append(...).

Should I migrate from LangGraph to Apache Burr?

Not unless you have a specific pain point that Burr solves better. Migration cost is real. If your LangGraph application is working and the main issues are debugging and production observability, integrating LangSmith more deeply is likely the lower-effort path. If you are starting a new project with reliability and auditability as primary requirements - or if Apache governance matters for your organization - starting with Burr makes sense.

Sources

• Apache Burr official site
• Apache Burr on GitHub
• Hacker News discussion: "Apache Burr: Build reliable AI agents and applications"
• LangGraph documentation
• CrewAI documentation
• Apache Software Foundation Incubator