Many AI agent failures are infrastructure failures, not intelligence failures. The model picked the right tool. The reasoning was correct. But a network timeout killed the pipeline — and you lost every completed step along with it.

The real problem runs deeper than reliability.

Modern AI agents are stochastic programs. They are not workflows. They are not pipelines. They are runtime-generated execution graphs driven by an LLM — the path through the problem is unknown until the model walks it.

Every existing durability system is built for deterministic programs. They assume a known execution graph, fixed control flow, predefined steps. That assumption is fundamentally incompatible with how LLM-driven agents actually work.

The result: there is no durability model for stochastic AI systems. Not in LangChain. Not in LangGraph. Not even in Temporal without rewriting everything.

duralang fills that gap — making fully stochastic agentic workflows completely durable for the first time.

---

See it in action:

https://github.com/user-attachments/assets/f99d4c45-e0f6-465d-b8da-8f40b3969d43

One decorator. That is the entire API change:

from duralang import dura, dura_agent

@dura
async def my_agent(messages):
    agent = dura_agent(
        model="claude-sonnet-4-6",
        tools=[web_search, calculator],
    )
    result = await agent.ainvoke({"messages": messages})
    return result["messages"]

Remove @dura → vanilla LangChain. Add it back → fully durable stochastic execution.

---

The guarantee:

You don't need the workflow to be deterministic. You just need each individual operation to be retryable. The LLM decides everything stochastically at runtime — which tools to call, in what order, how many times, when to stop. duralang doesn't constrain any of that. It just makes sure whatever the LLM decides cannot fail permanently.

Nondeterminism in the model. Durability in Temporal.

---

What you get automatically — zero configuration:

• Every LLM call → Temporal Activity (automatically retried on timeout or rate limit)
• Every tool call → Temporal Activity (heartbeated, independently retryable)
• Every MCP call → Temporal Activity (via langchain-mcp-adapters)
• Agent calling agent → Temporal Child Workflow (independently durable at every level)
• Full execution timeline in Temporal UI — free, self-hosted, no LangSmith subscription

No @workflow.defn. No @activity.defn. No manual serialization. No rewrite.

---

Full durability stack — applied to every operation automatically:

Layer	What It Does	Default
Retries	Exponential backoff on transient failures	3 attempts, 2× backoff
Timeouts	Bounded execution per operation	10 min (LLM), 2 min (tool), 5 min (MCP)
Heartbeating	Detects hung operations	5 min (LLM), 30s (tool/MCP)
State	Every step outcome recorded in event history	Automatic

All configurable per operation type:

from duralang import dura, DuraConfig, ActivityConfig
from datetime import timedelta
from temporalio.common import RetryPolicy

config = DuraConfig(
    task_queue="agents-prod",
    llm_config=ActivityConfig(
        start_to_close_timeout=timedelta(minutes=3),
        heartbeat_timeout=timedelta(seconds=30),
        retry_policy=RetryPolicy(maximum_attempts=5),
    ),
    tool_config=ActivityConfig(
        start_to_close_timeout=timedelta(minutes=1),
        retry_policy=RetryPolicy(maximum_attempts=4),
    ),
)

@dura(config=config)
async def my_agent(messages):
    ...

---

Durable multi-agent systems — stochastic all the way down.

Pass @dura functions as tools to dura_agent() and each sub-agent runs as an independent Temporal Child Workflow with its own event history:

orchestrator              ← stochastic, indestructible
├── dura__llm             ✅
├── researcher            ← Child Workflow, own event history
│    ├── dura__llm        ✅
│    └── dura__tool       ✅
└── analyst               ← Child Workflow, own event history
     ├── dura__llm        ✅
     └── dura__tool       ✅

Every level is stochastic — the LLM at each level decides independently what to do. Every level is also independently durable. If the analyst crashes, only the analyst retries. The researcher's completed work is preserved. The orchestrator keeps its progress.

Build arbitrarily deep agent hierarchies — every single level has the same durability guarantee.

---

Free observability — no LangSmith required.

Every LLM call, tool call, and agent call is fully visible in the Temporal UI at localhost:8233 — inputs, outputs, timing, retry count, and full event history. Self-hosted. No data leaving your infrastructure. No per-seat pricing. No subscription.

---

Built because this combination — fully stochastic LLM-driven agents with per-operation Temporal durability — did not exist anywhere before.

GitHub: https://github.com/deepansh-saxena/DuraLang

pip install duralang