Dapr Agents: A Framework for Agentic AI Systems
Dapr Agents is a developer framework designed to build production-grade resilient AI agent systems that operate at scale. Built on top of the battle-tested Dapr project, it enables software developers to create AI agents that reason, act, and collaborate using Large Language Models (LLMs), while leveraging built-in observability and stateful workflow execution to guarantee agentic workflows complete successfully, no matter how complex.
Key Features
- Scale and Efficiency: Run thousands of agents efficiently on a single core. Dapr distributes single and multi-agent apps transparently across fleets of machines and handles their lifecycle.
- Workflow Resilience: Automatically retries agentic workflows and ensures task completion.
- Kubernetes-Native: Easily deploy and manage agents in Kubernetes environments.
- Data-Driven Agents: Directly integrate with databases, documents, and unstructured data by connecting to dozens of different data sources.
- Multi-Agent Systems: Secure and observable by default, enabling collaboration between agents.
- Vendor-Neutral & Open Source: Avoid vendor lock-in and gain flexibility across cloud and on-premises deployments.
- Platform-Ready: Access scopes and declarative resources enable platform teams to integrate Dapr Agents into their systems.
Why Choose Dapr Agents?
Scalable Workflows as a First Class Citizen
Dapr Agents uses a durable-execution workflow engine that guarantees each agent task executes to completion in the face of network interruptions, node crashes and other types of disruptive failures. Developers do not need to know about the underlying concepts of the workflow engine - simply write an agent that performs any number of tasks and these will get automatically distributed across the cluster. If any task fails, it will be retried and recover its state from where it left off.
Cost-Effective AI Adoption
Dapr Agents builds on top of Dapr's Workflow API, which under the hood uses actors, a single unit of compute and state that is thread-safe and natively distributed, lending itself well to an agentic Scale-To-Zero architecture. This minimizes infrastructure costs, making AI adoption accessible to everyone. The underlying virtual actor model allows thousands of agents to run on demand on a single core machine with double-digit millisecond latency when scaling from zero. When unused, the agents are reclaimed by the system but retain their state until the next time they are needed. With this design, there's no trade-off between performance and resource efficiency.
Data-Centric AI Agents
With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic PDF extraction to large-scale database interactions, it enables seamless data-driven AI workflows with minimal code changes. Dapr's bindings and state stores provide access to a large number of data sources that can be used to ingest data to an agent.
Accelerated Development
Dapr Agents provides a set of AI features that give developers a complete API surface to tackle common problems. Some of these include:
- Multi-agent communications
- Structured outputs
- Multiple LLM providers
- Contextual memory
- Flexible prompting
- Intelligent tool selection
- Zero-config MCP integration — agents auto-discover MCPServer tools from the Dapr sidecar (see MCPServer auto-discovery below).
Integrated Security and Reliability
By building on top of Dapr, platform and infrastructure teams can apply Dapr's resiliency policies to the database and/or message broker of their choice that are used by Dapr Agents. These policies include timeouts, retry/backoffs and circuit breakers. When it comes to security, Dapr provides the option to scope access to a given database or message broker to one or more agentic app deployments. In addition, Dapr Agents uses mTLS to encrypt the communication layer of its underlying components.
Built-in Messaging and State Infrastructure
- 🎯 Service-to-Service Invocation: Facilitates direct communication between agents with built-in service discovery, error handling, and distributed tracing. Agents can leverage this for synchronous messaging in multi-agent workflows.
- ⚡️ Publish and Subscribe: Supports loosely coupled collaboration between agents through a shared message bus. This enables real-time, event-driven interactions critical for task distribution and coordination.
- 🔄 Durable Workflow: Defines long-running, persistent workflows that combine deterministic processes with LLM-based decision-making. Dapr Agents uses this to orchestrate complex multi-step agentic workflows seamlessly.
- 🧠 State Management: Provides a flexible key-value store for agents to retain context across interactions, ensuring continuity and adaptability during workflows.
- 🤖 Actors: Implements the Virtual Actor pattern, allowing agents to operate as self-contained, stateful units that handle messages sequentially. This eliminates concurrency concerns and enhances scalability in agentic systems.
Vendor-Neutral and Open Source
As a part of CNCF, Dapr Agents is vendor-neutral, eliminating concerns about lock-in, intellectual property risks, or proprietary restrictions. Organizations gain full flexibility and control over their AI applications using open-source software they can audit and contribute to.
Roadmap
Check the project view for some of the major features we're working on:
For a complete list of issue (including bug fixes) please check out our GitHub issues.
Language Support
| Language | Current Status | Development Status | Stable Status |
|---|
| Python | In Development | Q2 2025 | expected Q4 2025 |
| Other Languages | TBD | TBD | TBD |
Documentation
MCPServer auto-discovery
If your Dapr sidecar has any MCPServer resources loaded, Dapr Agents picks up their tools automatically — no tools= argument on the agent, no manual DaprMCPClient.connect(...) calls.
from dapr_agents import DurableAgent
agent = DurableAgent(
name="my-agent",
role="Multi-tool assistant",
runtime=workflow_runtime,
)
# MCPServer tools just work — no tools= configuration needed.
How it works:
- On agent init, Dapr Agents queries the Dapr sidecar's metadata API for the list of loaded
MCPServer resources.
- Before the agent's first turn, it uses the SDK's
DaprMCPClient to call dapr.internal.mcp.<server>.ListTools on each one.
- Each discovered tool is wrapped as a workflow tool that schedules
dapr.internal.mcp.<server>.CallTool.<tool> as a child workflow when invoked.
You can fine-tune behavior with AgentMCPConfig:
| Field | Default | Description |
|---|
enabled | True | Set to False to opt out of auto-discovery entirely. |
allowed_tools | None | Optional set of tool names; only matching tools register. None registers all. |
timeout_in_seconds | 30 | Per-server ListTools discovery deadline. |
Manual mode is still available — instantiate DaprMCPClient yourself, connect to specific servers, and pass converted tools via tools=... on the agent. The auto-discovery path simply removes the boilerplate when you want every loaded MCPServer wired in.
See the MCPServer example under examples/ for an end-to-end demo across all three transports.
Community
Contributing to Dapr Agents
Please refer to our Dapr Community Code of Conduct
For development setup and guidelines, see our Development Guide.
Quick start for contributors:
- Install dependencies:
uv sync --group dev --group test
- Install pre-push hooks:
pre-commit install --hook-type pre-push
- Make your changes and run tests:
uv run pytest tests -m "not integration"
- Push your changes - hooks will run automatically
Getting Started
Prerequisites:
Install Dapr Agents
dapr init
uv init
uv add dapr-agents
Run The Quickstarts
For a high level introduction to the fundamentals of Dapr Agents, see our quickstarts.
Run The Examples
Once you've gotten a feel for the fundamentals of the project in the quickstarts, then dive deeper with the examples.
See the durable deep agent example for a long-running research task that survives a crash and resumes.
Get Involved
Dapr Agents is an open-source project under the CNCF umbrella, and we welcome contributions from developers and organizations worldwide!
