AI Agents | Diagrid Docs

Agent frameworks like CrewAI, LangGraph, and others give you tools, LLM orchestration, and prompt management — but none of them handle what happens when things go wrong in production. Some offer basic checkpointing, but you still need to detect failures at scale, build your own recovery mechanisms, and coordinate resumption across instances to avoid duplicate runs.

Catalyst adds the missing infrastructure: automatic failure detection, automatic recovery at scale, and multi-instance agent coordination. Your agent code stays the same — Catalyst handles the rest.

Catalyst works with the following agent frameworks.

Dapr Agents

CrewAI

LangGraph

Strands

Microsoft Agent Framework

Google ADK

OpenAI Agents

Pydantic AI

Deep Agents

Deep Agents (Sub Agents)

note

Catalyst Cloud is free and the fastest way to get started — no infrastructure to set up. For production or on-premises requirements, Diagrid also offers self-hosted enterprise deployments.

Prerequisites

Diagrid Catalyst account
Diagrid CLI
Python 3.11+ — or .NET 8 SDK or later for the Microsoft Agent Framework tab
An OpenAI API key (or Google AI API key for Google ADK)

1. Log in to Catalyst

Confirm your identity:

2. Clone and Navigate

git clone https://github.com/diagridio/catalyst-quickstarts.git

Navigate to the quickstart directory for your framework:

cd catalyst-quickstarts/agents/dapr-agents/durable-agent

3. Explore the Code

Invitations Manager — a durable agent that sends event invitations to guests via email and physical mail. Dapr Agents is the native AI agent framework built on Dapr — durability, state, and pub/sub are built into the agent itself.

Open main.py. The agent uses Pydantic models for structured tool input and output:

from dapr_agents import tool, DurableAgent
from dapr_agents.llm import DaprChatClient

class InvitationSchema(BaseModel):
    guest_count: int = Field(description="Number of guests to invite")
    event_type: str = Field(description="Type of event")

@tool(args_model=InvitationSchema)
def send_invitations(guest_count: int, event_type: str) -> List[InvitationResult]:
    """Send event invitations to guests."""
    return [
        InvitationResult(sent=int(guest_count * 0.7), method="email"),
        InvitationResult(sent=int(guest_count * 0.3), method="physical mail"),
    ]

The DurableAgent class brings everything together — memory, state, registry, and pub/sub are all configured at the agent level:

agent = DurableAgent(
    name="invitations-manager",
    role="Invitations Manager",
    goal="Send event invitations to guests using the send_invitations tool.",
    tools=[send_invitations],
    llm=DaprChatClient(component_name="llm-provider"),
    memory=AgentMemoryConfig(
        store=ConversationDaprStateMemory(store_name="agent-workflow")
    ),
    state=AgentStateConfig(
        store=StateStoreService(store_name="agent-memory"),
    ),
    registry=AgentRegistryConfig(
        store=StateStoreService(store_name="agent-registry"),
    ),
    pubsub=AgentPubSubConfig(
        pubsub_name="agent-pubsub",
        agent_topic="events.invitations.requests",
        broadcast_topic="agents.broadcast",
    ),
)

runner = AgentRunner()
runner.serve(agent, port=8006)

tip

Unlike other frameworks, Dapr Agents has durability, state, pub/sub, and failure recovery built in natively. Automatic failure detection, crash recovery, and multi-instance coordination are all handled out of the box — no wrapper needed.

4. Configure API Key

This quickstart uses OpenAI as the LLM provider (or Google Gemini for ADK). Catalyst is LLM-agnostic — you're free to use any provider supported by your chosen framework.

The LLM is configured via DaprChatClient(component_name="llm-provider") — a Dapr component in resources/llm-provider.yaml that references your OpenAI API key:

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: llm-provider
spec:
  type: conversation.openai
  metadata:
  - name: key
    value: "{{OPENAI_API_KEY}}"
  - name: model
    value: gpt-4.1-2025-04-14

Update the key value with your OpenAI API key.

5. Install Dependencies

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

6. Run with Catalyst Cloud

diagrid dev run -f dev-python-durable-agent.yaml --project durable-agent-qs --approve

tip

diagrid dev run runs your code locally and connects it to the Catalyst Cloud workflow engine. Your agent code never leaves your machine — only workflow state is stored in Catalyst.

Wait for the log output indicating the runner is ready before proceeding.

You can open the Catalyst Cloud web console, navigate to the Agents section, and select your agent from the list to inspect its configuration and executions.

7. Trigger the Agent

Open a new terminal and trigger the agent:

curl -X POST http://localhost:8006/agent/run \
  -H "Content-Type: application/json" \
  -d '{"task": "Send invitations to 100 guests for a corporate networking event"}'

Expected output:

== APP == Invitations sent: 70 via email, 30 via physical mail

8. Crash Recovery

Your code runs locally throughout this test. The Catalyst Cloud workflow engine — not your machine — tracks which steps completed and stores their results. That's what makes recovery possible even after a full process crash.

Stop the running application with Ctrl+C.

Crash recovery is built into Dapr Agents natively — the DurableAgent class automatically persists each tool execution as a workflow activity. If the process crashes, it resumes from the last saved state. See the Durable Agent Quickstart for a detailed walkthrough.

tip

Because workflow state is stored remotely in Catalyst (not in your process), the engine replays saved results instead of re-executing completed steps. This works even after a full process crash.

9. View in the Catalyst Web Console

Open the Catalyst Cloud web console and navigate to the Workflows section. Select the workflow instance to inspect the full execution trace, including the input/output of every tool and LLM call and state persistence.

10. Clean Up

Stop the running application with Ctrl+C, then delete the Catalyst project:

diagrid project delete durable-agent-qs

Summary

In this quickstart, you:

Built a Dapr Agents durable agent with structured tool schemas and Dapr-native LLM configuration
Ran it locally connected to Catalyst Cloud for state persistence and crash recovery
Triggered the agent via REST API and inspected execution in the Catalyst console

Next Steps

Explore the Durable Agent Quickstart for a richer example with parallel tool execution
Try the Multi-Agent Quickstart to orchestrate multiple cooperating agents
Learn how to deploy AI agents to Kubernetes

Prerequisites​

1. Log in to Catalyst​

2. Clone and Navigate​

3. Explore the Code​

4. Configure API Key​

5. Install Dependencies​

6. Run with Catalyst Cloud​

7. Trigger the Agent​

8. Crash Recovery​

9. View in the Catalyst Web Console​

10. Clean Up​

Summary​

Next Steps​