DEV Community: Casper Nielsen

Durable Sessions for the Claude Agent SDK, in One Prompt

Casper Nielsen — Tue, 13 Oct 2026 06:52:34 +0000

We shipped a Claude Agent SDK executor in Dapr Agents with durable sessions and human approvals. Meaning: your Claude-built agent survives a crash mid-task, resumes with its session intact, and waits for an approval for as long as the approval takes – through restarts and deploys.

Getting started is rather easy:

pip install dapr-agents
dapr init

Then paste this into your agent definition:

from dapr_agents import DurableAgent
from dapr_agents.executors import ClaudeAgentExecutor

agent = DurableAgent(
    name="reviewer",
    executor=ClaudeAgentExecutor(session_store="statestore"),
    require_approval=["merge_pr", "deploy"],
)
agent.start()

Now break it on purpose, because that's the whole point:

Give it a multi-step task.
kill -9 the process somewhere in the middle.
Start it again. The session resumes where it stopped and the steps already completed come back from the journal, not from re-running Claude.
Trigger an approval-gated tool, close your laptop, approve tomorrow. The wait survives because it lives in the workflow, not in memory.

All behavior was checked against dapr-agents main; the release notes have the exact versions: https://github.com/dapr/dapr-agents/releases

Same machinery works for LangChain Deep Agents. The adapter landed earlier this year in our diagrid python package, and deep agents with long tasks are exactly where durable sessions pay off.

If you want the guided version, the Dapr Agents track at Dapr University is free: https://www.diagrid.io/university/dapr-agents

It's that easy to get started. Give it a spin and lmk what you think 👀

Hooks: Steer Your Agent Before the LLM Call

Casper Nielsen — Fri, 09 Oct 2026 07:51:25 +0000

Small feature, outsized leverage: Dapr Agents lets you register hooks around the agent loop where the before_llm_call being the one I use the most.

from dapr_agents import DurableAgent

def add_live_context(ctx):
    ctx.messages.append(web_search(ctx.task))  # fresh context, every call

agent = DurableAgent(
    name="researcher",
    hooks={"before_llm_call": add_live_context},
)

Everything the hook does, lives inside the durable workflow, so a crash after the hook but before the call replays cleanly with no lost context. That's the difference between bolting logic onto the loop and having the runtime own it. It's important to note here that the hook itself has to be replay safe. Furthermore, the hook author needs to define whether this hook is deterministic or not. This has impact on replaying. A web search, as the above example is, will not be deterministic and thus will rerun. For live context, this is great and probably what we want. For validating user tokens, this is equally great - otherwise we'd just roll an approval on a potentially expired token!

Uses we've seen in the wild: injecting fresh web context (my webinar demo), token-budget enforcement before the spend happens, redacting PII on the way in - and on the way out too. The latter is powerful to use if your agent handles sensitive data you'd want to mask before sending to an LLM provider.

The webinar takes you through a full example with Tavily and Chainlit to enrich a models answer with fresh web results: https://www.diagrid.io/webinars/make-your-llm-agent-production-smart

Give it a spin and lmk what you think!

[Boost]

Casper Nielsen — Tue, 06 Oct 2026 20:01:11 +0000

Marc Duiker for Diagrid

Oct 5

What's New in the Dapr Dev Dashboard for Local Workflow Debugging

#dapr #debugging #programming

7 min read