Introducing Dapr Durable Execution for goose: AI agents that pick up where they left off

goose can execute complex tasks. Now, with Dapr Durable Execution, it can survive crashes and resume its work without starting over.

We're excited to announce a new open-source integration between goose and Dapr, bringing durable execution to goose agents with just a few lines of Rust. Dapr is a community project supported by Diagrid, NVIDIA and dozens of other contributing organizations, hosted by the Cloud Native Computing Foundation

The problem: Your agent is only as reliable as its runtime

goose is great at autonomous work: writing code, interacting with tools, investigating problems, and executing multi-step tasks.

But what happens when an agent is halfway through a task and its process crashes, its container restarts, or its machine goes down?

Previously, goose could persist conversation sessions, but that alone didn't provide durable orchestration of a multi-step execution. Developers still needed to manage interrupted runs, track completed work, and decide what to execute again.

For long-running agents, this creates real problems: wasted LLM tokens, duplicated work, lost execution progress, and custom recovery logic.

What's new: Durable execution for goose

With the new diagrid-goose integration, goose runs inside a Dapr Workflow. Each conversation turn becomes a durable, checkpointed workflow activity.

This unlocks three important capabilities:

• Resume after crashes. If an agent is interrupted, it can continue when the worker restarts, recovering its existing goose session.
• Don't repeat completed work. Finished turns are recorded in Dapr's workflow history and aren't re-executed during recovery.
• Preserve context across restarts. The agent retains its conversation history, allowing it to continue reasoning about the task rather than beginning a new conversation.

All of this works with goose's existing model providers and tool ecosystem. No need to rewrite Goose or build your own workflow engine.

Getting started is simple

Add the integration to your Rust project:

cargo add diagrid-goose

Register goose with the Dapr Workflow runtime:

let mut client = WorkflowClient::new().await?;
diagrid_goose::register(client.registry_mut());
let worker = client.start_worker().await?;

Now define the work you want goose to perform:

let input = GooseWorkflowInput {
    program: "goose".into(),
    args: vec!["acp".into()],
    env: vec![],
    cwd: std::env::temp_dir(),
    tasks: vec![
        "Create a deployment checklist.".into(),
        "Turn it into a rollout plan.".into(),
    ],
};

Schedule it as a durable workflow:

client.schedule_workflow(
    diagrid_goose::WORKFLOW_NAME,
    ScheduleOptions::new().try_with_input(input)?,
).await?;

That's the core integration. Dapr handles workflow checkpointing and recovery while Goose continues doing what it does best: executing tasks.

Don't take our word for it. Crash your agent.

We've included a runnable example that makes the recovery behavior easy to see.

With Dapr and Goose installed and configured, clone the repository and run:

git clone https://github.com/diagridio/rust-ai
cd rust-ai/crates/diagrid-goose

dapr run --app-id goose-quickstart \
  --resources-path ./examples/resources \
  -- cargo run --example quickstart

Interrupt the execution with Ctrl+C, then run the same command again.

The workflow resumes. Previously completed turns aren't repeated, and the interrupted turn continues using the saved goose session.

There is no need to implement your own crash-recovery machinery.

For production deployments, goose's session storage must remain persistent across worker restarts. Durability is currently at the conversation-turn level, so external side effects within an interrupted turn still need appropriate idempotency safeguards.

From autonomous agents to reliable autonomous systems

Agent intelligence is only one part of building useful AI systems. Agents also need to reliably finish the work they start.

By combining goose with Dapr durable execution, developers get the autonomy of Goose backed by the reliability of durable workflows.

Build with goose. Keep it running with Dapr.

The integration is open source and available today.

Explore the integration and examples on GitHub