Use cases

Catalyst is a managed platform for applications that need durable execution, identity, and policy enforcement — long-running business processes, AI agents that survive crashes, MCP tool servers, and the secure infrastructure that connects them. The scenarios below are the most common patterns teams build on Catalyst today.

AI agents

Build intelligent, autonomous AI agents that can interact with external systems, make decisions, and orchestrate complex workflows using durable execution patterns and pluggable infrastructure.

Durable Agents

The Dapr Agents framework enables durable agents that persist their execution state across restarts and failures. Unlike traditional agents that lose context when they crash, durable agents can resume exactly where they left off.

It leverages the Dapr Conversation API which provides an abstraction layer for LLMs, enabling agents to switch between model providers without code changes. Conversation components handle the integration with different LLM providers and add capabilities like response caching, PII protection, and resilience.

Key capabilities:

• Durable executions - Every step in the agent's reasoning and execution is automatically saved, allowing recovery from failures without losing progress or repeating expensive LLM calls
• Built-in resiliency - Automatically retry failed operations and recover from transient failures in external systems or LLM APIs
• Pluggable memory and context — store conversation history in any of the 28+ Dapr state store components, from Redis and PostgreSQL to AWS DynamoDB and Azure Cosmos DB.
• Provider agnostic - Swap between OpenAI, Azure OpenAI, AWS Bedrock, Google Vertex AI, and more without changing agent code
• Prompt caching - Reduce latency and costs for repeated calls
• Security and PII obfuscation - Protect sensitive data automatically
• Built-in resiliency - Retries, timeouts, and circuit breakers
• Observability - OpenTelemetry tracing and Prometheus metrics out of the box

Why Durability Matters

Traditional agents lose all context when they crash. If an agent fails after 10 LLM calls and 5 API interactions, you have to start over—repeating expensive operations and potentially getting different results. Durable agents checkpoint their state automatically, so they resume exactly where they left off.

Multi-agent workflows

For complex business processes, you can orchestrate multiple agents within deterministic workflows. Dapr Agents integrates seamlessly with Dapr Workflow, letting you combine the intelligence of LLMs with the reliability and predictability of workflow orchestration.

This is ideal for scenarios like customer support triage, multi-stage data processing, or any flow where you need conditional logic, parallelization, or human-in-the-loop between AI reasoning steps.

What Catalyst adds

• Per-agent identity — each agent runs under an App ID with a SPIFFE-based x.509 certificate. Access policies decide which tools, MCP servers, and downstream services it can reach.
• Secure app-to-app communication — short-lived mTLS certificates with automatic rotation encrypt and mutually authenticate every call between agents and services.
• Cross-cloud identity federation — agents authenticate to AWS, Azure, and GCP services without storing or distributing long-lived secrets.
• Centralized credentials — when needed, API keys (such as LLM credentials) are stored and managed at the platform layer rather than in application code.
• Complete observability — full visibility into each step of an agent's execution, including timing, inputs, outputs, and tool invocations, surfaced on the Agents page in the Catalyst Console and in the API logs.
• Auditing and traceability — all operations are tied to workload identity for end-to-end audit trails.

Start here: AI agent quickstart for working code, then Develop AI agents and the AI agents concept.

Workflows

Long-running, multi-step orchestrations with checkpointing, retries, durable timers, and fan-out/fan-in. Used for business process automation (order processing, claims adjudication, document review), data pipelines, and any operation that must survive process restarts and infrastructure failures — including workflows that pause for a human decision and resume days later.

Workflow as code

Dapr Workflow lets you define workflows programmatically using any supported language SDK (Python, JavaScript, .NET, Java, Go). You express complex orchestration logic with the full power and flexibility of a programming language, including conditionals, loops, error handling, and type safety — for example, an order approval workflow that auto-approves small orders, waits up to seven days for a human approval on larger ones, and handles the timeout path explicitly.

Key capabilities

• Durability — every workflow step is persisted in a backing store (SQL, NoSQL, or cloud service), so workflows survive process restarts and continue from their last recorded state.
• Built-in resiliency — durable retry policies track retry state, wait with durable timers, and continue after restarts with automatic retries, timeouts, and circuit breakers.
• Child workflows — compose complex processes by breaking them down into reusable sub-processes.
• Multi-application workflows — orchestrate business processes that span different application instances, enabling workflow and activity reuse across services.
• Timers and reminders — schedule delays or future events with durable timer support.
• External events — wait for human approvals, external system responses, or custom triggers without holding compute.

What Catalyst adds

• Managed workflow runtime — workflow state lives in the Catalyst-managed store; activity workers scale independently of the orchestrator; failures resume from the last checkpoint, not from scratch.
• Workflow dashboard — monitor execution states (Running, Completed, Failed) and aggregate success rates across workflows for quick health insights.
• Execution visualization — view real-time diagrams of workflow paths, including branching, parallel activities, and dependencies.

• Execution history — full workflow timelines, durations, and outcomes for debugging and auditing.
• Input and output inspection — examine data at each stage of an execution.
• API logs — inspect real-time Dapr API calls (Workflow, State, Pub/Sub, Invocation) for end-to-end visibility.

Start here: Workflow quickstart for working code, then Develop workflows in your language, the Workflow concept, Durable execution, and Workflow patterns.

MCP servers

A server that exposes tools or data to AI agents over the Model Context Protocol (MCP), without you writing authentication, authorization, retry, or observability code in the server itself. Typical shapes: internal tool servers that wrap company APIs, databases, or SaaS systems and make them callable by any MCP-compatible agent.

What Catalyst adds

• Authentication outside the protocol — a bearer middleware on the MCP server's HTTP pipeline validates OAuth2 JWTs (Auth0, Okta, Azure AD, any standard provider) before requests reach server code. No changes needed to the MCP server itself.
• Declarative authorization — access policies decide which agent App IDs can invoke which servers and which downstream tools, configured per project as YAML.
• Runtime discovery via the MCP Catalog — agents discover available MCP servers at runtime instead of hard-coding endpoints, with per-agent visibility controlled by policy.
• mTLS and resiliency for free — retries, timeouts, circuit breakers, and mutual TLS are applied by the Catalyst data plane, not by the server.
• Per-server identity — MCP servers can runs under an App ID, so audit logs and access decisions are tied to workload identity rather than shared API keys.

Start here: Develop with MCP, then MCP authentication and MCP access policies, and the MCP concept for the auth model.

Microservices

Build resilient microservices with service discovery, state management, and reliable messaging patterns, decoupled from underlying infrastructure across on-premises and cloud environments.

Resilient orchestration

In microservices architectures, ensuring data consistency and coordinating long-running business processes across services is challenging when each service owns its data. Dapr Workflow provides stateful, fault-tolerant orchestration that makes it easy to express multi-step business logic, handle retries, and maintain consistency across services.

One common pattern is the Saga pattern, which breaks distributed operations into a sequence of local transactions, each executed within its own service and database. If any step fails, compensating actions revert previous changes to keep the system consistent.

Key capabilities:

• Workflow orchestration — define complex business processes in code with guaranteed execution through durable, stateful workflows.
• Saga pattern — orchestrate interactions across services with reliable consistency without distributed transactions.
• Transactional outbox pattern — automatically propagate database changes to other services using asynchronous pub/sub.
• Compensation logic — roll back or undo operations when workflows fail partway through.

Service-to-service communication

Synchronous request-reply remains one of the most common communication patterns in microservices, but doing it reliably in production requires service discovery, secure communication, and handling transient failures.

The Dapr Service Invocation API lets applications discover and communicate with each other securely, with built-in resiliency and observability.

Key capabilities:

• Service discovery — automatically locate and route to target services in dynamic environments.
• Built-in resiliency — retries, timeouts, and circuit breakers protect against transient failures and prevent cascading failures.
• Secure communication — mTLS authentication and encryption for all service-to-service traffic.
• Observability — automatic distributed tracing and metrics for all service calls.

State management

The Dapr State API provides a key/value interface with pluggable state stores for persistence, so microservices can maintain state across requests and restarts.

Rather than being locked into a single database, state management lets you choose from different state store providers — Redis, PostgreSQL, AWS DynamoDB, Azure Cosmos DB, and more.

Key capabilities:

• Transactional operations — atomic multi-item transactions across state stores.
• State TTL — time-to-live values on entries for automatic expiration.
• Encryption at rest — provider-agnostic encryption and key rotation.
• Querying and bulk operations — query syntax for filtering and sorting, with bulk reads and writes for performance.

Job scheduling

Many microservices need scheduled work - running nightly database backups, executing daily ETL pipelines, sending periodic email reports, or settling financial transactions at the end of the business day. The Dapr Jobs API provides an orchestrator for scheduling jobs to run at specific times or intervals.

Key capabilities:

• Job scheduling - Schedule one-off or recurring jobs to run at specific times or intervals with durable execution guarantees
• Reliable execution - Jobs are durable and survive process restarts and infrastructure failures, ensuring scheduled tasks still run

Infrastructure portability

Dapr's component model decouples application code from underlying infrastructure. Change your message broker by swapping a YAML configuration file (RabbitMQ → Kafka, Azure Service Bus → Google Pub/Sub) without modifying application code. The same applies to state stores, secret stores, and bindings.

What Catalyst adds

• Managed control plane and sidecar runtime — same Dapr SDKs your code already uses, with no sidecars to deploy or upgrade.
• Reliability and resiliency policies — retry, timeout, and circuit breaker policies defined at the platform level apply consistently across all services.
• Access control policies — declare which services can communicate with each other and what operations they can perform.
• Application graph — visualize how services interact with each other and their infrastructure dependencies, showing synchronous calls and asynchronous messaging flows.

• Metrics dashboards — golden signals (latency, throughput, error rates) per service.
• API call inspection — drill into individual API calls to analyze failures, latency, and end-to-end behavior.
• Distributed tracing — follow requests across service boundaries with automatic trace propagation.

Start here: Dapr APIs quickstarts for working code, then Develop with the Dapr APIs, the Dapr APIs concept, and Components.

Event-driven architecture

Build scalable event-driven applications using a unified messaging API that abstracts away broker complexity and provides guaranteed delivery, content-based routing, and multi-cloud portability.

Event-driven messaging

The Dapr Pub/Sub API lets producers publish events without knowing who consumes them, so services evolve and deploy independently. Consumers scale on their own timeline, absorb workload spikes, and shed load gracefully without impacting upstream systems.

Key capabilities:

• Asynchronous communication — avoid blocking calls and process work without requiring immediate responses.
• Loose coupling — producers and consumers evolve independently without direct lifecycle dependencies.
• Pull and push models — pick the consumption pattern that fits each subscriber.
• Interoperability between systems — integrate across languages, cloud services, and legacy systems through events.
• Bulk operations — send or receive multiple messages in a single request for higher throughput.

Guaranteed message delivery

Dapr Pub/Sub provides at-least-once delivery so events are never lost during network issues, restarts, or downstream failures. Combined with built-in resiliency policies and dead-letter queues, you get a reliable, fault-tolerant messaging layer.

Key capabilities:

• At-least-once delivery — messages are retried automatically and not lost during failures.
• Dead-lettering — route failed messages to dedicated topics for debugging and reprocessing.
• Outbox pattern — guarantee message publication only when database transactions commit.
• Message TTL — automatically expire stale messages to prevent backlogs.

Broker abstraction

One consistent API across all message brokers and programming languages, with no need to learn each broker's client library or operational model.

Key capabilities:

• One API for all brokers — Kafka, RabbitMQ, Redis Streams, Azure Service Bus, AWS SNS/SQS, Google Pub/Sub, and 20+ additional brokers.
• HTTP + SDK access — publish and subscribe using HTTP only or a single SDK.
• Infrastructure-neutral — decouple application logic from broker configuration and operational details.
• CloudEvents standard — standardize event structure across systems with a vendor-neutral format.

What Catalyst adds

• Identity-based access — publish and subscribe permissions are tied to the App ID, not to shared broker credentials.
• Durable retries on subscriber failures, with dead-letter routing applied by policy.
• Pub/sub authentication via App ID rather than shared keys.
• Topic-level access control — only authorized applications may publish or subscribe to a given topic.

Start here: Pub/sub quickstart for working code, then Develop with the Dapr APIs and the Dapr APIs concept.