Durable AI workflows,
on your infrastructure.
The open-source control plane for AI agents. Every step is an event, so runs replay, resume after a crash, and audit exactly — in a single binary you run yourself.
curl -fsSL https://duragraph.ai/install.sh | shReliability is not a feature you add later. It is the substrate.
Agentic systems fail where ordinary services don't — a model times out mid-plan, a tool runs twice, an approval never arrives. DuraGraph records every transition as an immutable event, so a crashed run resumes exactly where it stopped, and the same log powers replay, audit, and observability. One mechanism, three guarantees.
All of it is Apache 2.0 and self-hosted — your graphs, prompts, and data never leave your infrastructure.
Event sourcing & CQRS, all the way down.
The gateway persists to the append-only Postgres event store; events publish to NATS JetStream; workers pull the stream, run agents, and reconcile state back. Drag any node to rearrange.
From graph to durable run.
- 01Define
Design the graph
Model the workflow as nodes and edges: the graph is the program.
- 02Author
Write in Python or Go
Familiar SDKs and patterns. First-class support for any LLM provider.
- 03Run
Execute durably
Every step is appended to the log with at-least-once delivery guarantees.
- 04Observe
Replay & monitor
Real-time metrics and OpenTelemetry traces, plus full-fidelity replay.
Define a graph, in Python or Go.
Model the workflow as nodes and edges, then point a worker at duragraph dev. It registers on startup — no codegen, no DSL.
from duragraph import Graph, llm_node, entrypoint
@Graph(id="customer_support")
class CustomerSupportAgent:
@entrypoint
@llm_node(model="gpt-4o-mini")
def classify(self, state):
return {"intent": "billing"}
@llm_node(model="gpt-4o-mini")
def respond(self, state):
return {"response": f"handling {state['intent']}"}
classify >> respond
# deploy to the running control plane
CustomerSupportAgent().serve("http://localhost:8081")type ChatState struct {
Result string `json:"result,omitempty"`
}
type ThinkNode struct{}
func (n *ThinkNode) Execute(
ctx context.Context, state *ChatState,
) (*ChatState, error) {
state.Result = "Hello from Go!"
return state, nil
}
func main() {
g := graph.New[ChatState]("my_agent")
g.AddNode("think", &ThinkNode{})
g.SetEntrypoint("think")
// connect to the running control plane
w := worker.New(g,
worker.WithControlPlane("http://localhost:8081"))
w.Start(context.Background())
}From single agents to enterprise workflows.
AI Agents
Memory, tool use, multi-step reasoning.
Data Pipelines
ETL with retries and fault tolerance.
Research Labs
Reproducible runs with full lineage.
Enterprise Apps
Mission-critical workflows, audited.
The spec sheet.
Before you self-host.
Where does my data live?
On your own Postgres and network. Self-hosted, never phones home.
Can I run it air-gapped?
Yes — a single binary with embedded Postgres and NATS, no required outbound calls.
How does it scale?
Workers scale horizontally with optimistic concurrency, lease-epoch fencing, and a transactional outbox.
Which LLM providers are supported?
Any — first-class OpenAI and Anthropic, with per-node model choice.
Do I need Docker or Kubernetes?
No. duragraph dev runs everything embedded; production points at your own Postgres and NATS.
Is it really open source?
Core is Apache 2.0; enterprise features are source-available. Your data is always yours.
Run your first durable agent in a minute.
One binary, with embedded Postgres and NATS. Nothing to provision.
curl -fsSL https://duragraph.ai/install.sh | sh