Dapr Agents 1.0: Durable, Cloud-Native, Production-Ready

A year ago, Dapr Agents joined the Dapr ecosystem as a developer framework for building AI agents on top of cloud-native APIs from Dapr, including Dapr Workflow for long-running agents. Since then, it has gone through 20 releases, stabilized its APIs, and shipped the capabilities needed to run agents in production: durable execution, persistent memory, resiliency, structured tool calling, and multi-agent orchestration. Today, we are announcing Dapr Agents v1.0, the fully production-ready release. This milestone marks a shift from experimentation and prototypes to agents you can deploy, operate, and trust in production environments. Dapr Agents v1.0 is about building reliable and secure agentic systems, not chatbot demos.

Community Growth and Real-World Adoption

Originally started by Roberto Rodriguez from NVIDIA, Dapr Agents has grown rapidly since its initial release. The project has shipped over 20 releases in under a year, iterating fast on core APIs, durability primitives, and developer experience. The Python package now sees over 8,000 monthly downloads on PyPI, with daily downloads often topping 1,000. On GitHub, the project has attracted a growing contributor base, with active community participation through Discord, community calls, and pull requests. Here at Diagrid we have dedicated full-time engineers contributing to the project and coordinating these releases as the primary maintainer.

The organizations who are building with Dapr Agents in production are the clearest signal of readiness.

ZEISS Vision Care is using Dapr Agents to orchestrate document data extraction workflows. Their Software Architect, Fabian Steinbach, will present this work in a keynote at KubeCon + CloudNativeCon Europe 2026 in Amsterdam, "Orchestrating Document Data Extraction with Dapr Agents." This is a durable, multi-step agent pipeline processing real enterprise documents at scale.

A large EU logistics company is using Dapr Agents for warehouse operations. Running fully on-prem, the system helps warehouse managers save time by automating routine actions, flagging at-risk orders, predicting stockouts, and optimizing task assignments. The result is faster operations and significant cost savings across fulfillment workflows.

These are just two examples. Many other teams are building systems that benefit from Dapr Agents and Dapr's cloud-native capabilities, especially for workloads that need to respond to events, execute reliably, coordinate with durable workflows, and run on Kubernetes. The demand is clear: when you need an agent that is reliable, cloud-native, long-running, secure and able to survive failures, Dapr Agents is a strong fit.

Build a Durable Agent in Minutes

A durable agent is an agent whose execution runs inside a persistent or durable workflow. Not just its memory, but the execution steps are persisted: the user input, intermediate steps, tool calls, and decisions. If the process crashes, it resumes from exactly where it left off, not from the beginning or some arbitrary checkpoint set by a developer. What's more, this is automatically detected for you and resumed on process recovery (typically from a pod restart) so there is no failure detection required.

Here is a tiny durable agent built with Dapr Agents:

from dapr_agents import DurableAgent
from dapr_agents.workflow.runners import AgentRunner
 
runner = AgentRunner()
agent = DurableAgent(name="Assistant", 
system_prompt="You are a helpful assistant")
 
try:
   runner.subscribe(agent)  # to a pubsub broker
   runner.serve(agent, port=8001)
finally:
   runner.shutdown()

That's it. Ten lines of Python. But even this tiny agent has a lot built in:

• Durable agent execution with persisted agent execution state via the Dapr Workflow API
• Distributed computation with each step within the workflow can be distributed across the cluster to scale effectively and uses minimal resources.
• Conversation memory persisted into an external state store so it survives restarts. You can choose from more than 25 different DBs to fit with your existing or future choices
• Synchronous and asynchronous endpoints exposed automatically for triggering the agent through either HTTP or Pub/Sub messaging.
• LLM provider decoupling through the Dapr Conversation API, so you can swap LLMs without code changes and choose from a wide range of providers and models
• A SPIFFE identity and mutual TLS for true agent identity and secure communication. The SPIFFE identity allows agents to authorize calls from other agents and importantly provides access rights to infrastructure services such as DBs, message brokers etc.
• Distributed tracing events written to OTEL endpoints and Prometheus metrics, with no instrumentation code required.
• Agent auto-registration into a runtime agent registry for discovery, operational visibility, and multi-agent orchestration.

All of this is enabled through Dapr's architecture. You configure the infrastructure with YAML components, and the agent code stays focused on business logic.

Why Agent Durability Matters

Most agent frameworks are not durable, because they do not persist execution state in a way that reliably survives failures and leave too much of the recovery burden to the operations team. That may be acceptable for demos or chatbots, but it falls apart in business-critical production systems or at scale.

Production agents face a different set of problems:

• Long-running tasks. An agent processing a support ticket might need to check entitlements, query a knowledge base, call an external API, wait for a human review, and generate a resolution. This takes time, and more things can go wrong.
• External dependencies. Every tool call depends on other systems, and things go wrong.
• Crash recovery. In cloud environments, failures happen and auto-recovery is expected. Pods get evicted, nodes go down, and deployments roll. The agent must resume, not start over.
• Observability and auditability. Every step of the agent's execution should be visible, persisted, and auditable so teams can debug issues, troubleshoot behavior, and review what happened after the fact.

Dapr Agents solves these problems by running every agent invocation as its own durable workflow. Every prompt, every interaction, and every trigger of the agent runs through a durable execution path with persisted state. And it is not just the agent itself: interactions between agents are coordinated through workflows, whether you want deterministic orchestration or dynamic agent-to-agent collaboration. The result is agents that are production-ready by construction, not by bolting on infrastructure after the fact.

Why Agent Security Matters

As AI agents increasingly operate across APIs, data stores, and enterprise systems, they begin to resemble distributed workloads rather than simple chat interfaces. Yet most agent frameworks today rely on static API keys or shared credentials, creating gaps in provenance, authorization, and auditability. This makes it difficult to confidently understand which agent performed an action, under what permissions, and whether that behavior aligns with organizational policy. Establishing a consistent identity layer is a key step toward making agentic systems more trustworthy and manageable in real-world environments.

Agent identity enables agents to participate in modern zero-trust architectures using familiar workload identity patterns. Standards such as SPIFFE provide a way to assign cryptographically verifiable identities to software workloads, enabling secure service-to-service communication, fine-grained authorization, and traceable chains of delegation. Applying these principles to agents helps reduce credential sprawl while improving observability and policy enforcement, particularly as multi-agent systems collaborate dynamically across tools and services.

With Dapr Agents v1.0, these identity concepts are built-in. By aligning with established approaches such as SPIFFE-based workload identity, Dapr Agents aims to make it easier for teams to build agentic applications that integrate cleanly into existing cloud-native security models. Treating identity as a foundational capability helps create a more interoperable and practical path toward operating agents alongside the rest of the distributed systems stack.

Top 10 Features of Durable Agents

This release is the result of a year of development, community feedback, and production hardening. Here are ten of the most important capabilities, and why they matter.

1. Durable execution. DurableAgent runs as a full Dapr Workflow instance with persisted state and built-in durable retries. This is the foundation of the framework: every agent invocation can recover from failures without losing progress or restarting from scratch.

2. Swappable agent memory. The agent's conversation memory can be backed by in-memory lists or by many different Dapr-supported state stores, whether cloud-based or self-hosted. This gives teams the flexibility to start simple, move to persistent memory in production, or choose the backend that best fits their environment.

3. Unified LLM integration. The Dapr Conversation API lets you swap LLM providers without code changes, with additional native clients for OpenAI, Azure OpenAI, NVIDIA, Hugging Face, and ElevenLabs. Reduces lock-in and makes it easier to standardize agent infrastructure across different models and vendors.

4. Structured outputs, tool calling, and prompt templating. Dapr Agents supports JSON Schema and OpenAPI v3.1 compliant outputs, native function calling, typed validation, and Prompty-based prompt templates.

5. MCP support. Model Context Protocol integration enables dynamic discovery and invocation of external tools over stdio, SSE, or HTTP.

6. Deterministic multi-agent orchestration. Durable Agents can be invoked as child workflows in a fixed orchestration pattern. This is important when teams need predictable execution, auditability, and tight control over how specialized agents coordinate.

7. Autonomous multi-agent orchestration. Durable Agents can discover and orchestrate other agents dynamically at runtime. This enables more adaptive systems, where agents can delegate work based on the problem instead of following only hardcoded paths.

8. Agent Registry. Agents automatically register themselves in a runtime Agent Registry for discovery by other agents and operations teams. This makes multi-agent systems easier to inspect and operate in production.

9. OpenTelemetry tracing. Full instrumentation spans agents, tools, and LLM calls with W3C context propagation.

10. Core APIs stabilized. The DurableAgent, and its related APIs surface are now stable and designed for backward compatibility going forward. This gives developers a firmer foundation to build on, with more confidence that production code will not break with each release.

What You Can Build with Dapr Agents

Dapr Agents provides a flexible foundation for building business-critical agentic applications in production. Here are some of the scenarios we are seeing teams and the broader community build with it.

Document and data processing. Build agents that extract, classify, validate, and route information across documents and business systems.

Operations automation. Build agents that respond to events, automate routine work, coordinate workflows, and help teams move faster with less manual effort.

Support and service workflows. Build agents that triage tickets, gather context, suggest next steps, and hand work to a human when needed.

Developer tooling and documentation workflows. Build agents that analyze pull requests, generate or update documentation, package automation into CI/CD or GitHub Actions, and keep developer workflows consistent with code changes.

Multi-agent business processes. Build systems where specialized agents coordinate across steps such as planning, analysis, approvals, and execution.

These examples are meant as inspiration, not a fixed list. The point is that Dapr Agents provides a flexible foundation for building reliable agentic applications that can run in production.

Where to deploy your agents?

Once you have developed your agent locally, how do you put these into production for ongoing development and operations? This is what Diagrid's AI Platform, Catalyst provides. Everything you need to deploy your agents into production with an agent registry, visibility into your agent for diagnostics, MCP server deployment and authentication, team projects for RBAC, identity allocation for agents, easy to configure DBs for durable state and more. You can try out Diagrid Catalyst Cloud for free and deploy your first agent in under 10 mins with this quickstart tutorial.

Get Started

Dapr Agents 1.0 is available today. Install it with:

pip install dapr-agents

The fastest way is through the Dapr Agents Quickstarts, which walk you through building agents step by step, from a simple assistant to multi-agent orchestration. For a full hands-on environment to learn Dapr Agents, sign up to Diagrid University. To dive into understanding how your agents work and then put them onto a path to production, sign-up for Catalyst Cloud for free.

We are always excited to see what you build. If you need to put your agents into production, reach out to us and we can make you successful.

If you are at KubeCon Europe 2026 in Amsterdam this week, join the Dapr sessions to see durable agents in action, including the ZEISS keynote on Tuesday and the deep dive on multi-agent orchestration with automatic recovery.

When agents need to run reliably in production, build them with Dapr Agents.