Durable execution has emerged as a baseline expectation for modern agent workloads. Imagine a multi-step refund process; if the agent’s process crashes midway, durable execution lets it pick up precisely where it left off instead of blindly retrying or redoing prior steps. This ensures robustness against failures and service interruptions, a must-have for reliable AI-powered automation.

But durability alone isn’t enough. When harnessing AI agents that make dynamic, autonomous decisions, it’s no longer enough to just "replay" a run. You need proof — a transparent, cryptographically sound record of what decisions the AI made, which tools it chose, and what data it processed at every step. This is where verifiable execution enters the scene.

In this post, we peel back the layers of durable and verifiable execution in agent systems. We’ll explore why reproducibility is challenged by autonomous AI, how verifiability restores accountability, and what Microsoft Diagrid’s Catalyst framework contributes as a new standard for trustworthy agent orchestration.

Architecture Overview

┌─────────────────────────────────────────────┐
│          Agent Workloads & Services          │
├─────────────────────────────────────────────┤
│ • AI Models (LLMs)                           │
│ • Tool Integrations (APIs, databases etc.)  │
│ • Agent Decision Logic                       │
└─────────────────────────────────────────────┘
                 ↓ Durable & Verifiable Execution ↓
┌─────────────────────────────────────────────┐
│          Diagrid Catalyst Framework          │
├─────────────────────────────────────────────┤
│ • Workflow Management                        │
│ • Cryptographic Signing & Attestation       │
│ • SPIFFE-based Workload Identity             │
│ • Agent Run Replay and Integrity Proof      │
└─────────────────────────────────────────────┘
                 ↓ Enables Auditable Agent Runs ↓
┌─────────────────────────────────────────────┐
│           Consumer Applications              │
├─────────────────────────────────────────────┤
│ • Dispute Resolution                         │
│ • Customer Service Automation                │
│ • Business Process Automation                │
└─────────────────────────────────────────────┘

This layered design clarifies the flow from raw AI functionality and business logic through a durable/verifiable runtime to the consuming applications that rely on trustworthy agent decisions.

Image credit: DEV Community

Key Technical Observations

• Durable Execution vs. Reproducibility Tradeoff — Durable runs enable agents to survive crashes and resume midway, but do not guarantee that runs are reproducible or explainable due to AI model-driven decision autonomy.

• Verifiable Execution Adds Cryptographic Proof — Every LLM call, external tool invocation, and decision is cryptographically signed and attested, creating an immutable, verifiable ledger of the agent’s behavior and outcomes.

• Decoupling Decision Logic from Code — Unlike deterministic workflows where decision logic is code-determined and fully reproducible, agent autonomy shifts decisions out of code into runtime, demanding run-level recording instead of static branching.

• Agentic Durable Execution as a Third Way — Catalyst extends code-first agent frameworks by adding durable and verifiable semantics without forcing workflow declarations outside the codebase, preserving developer flexibility.

• SPIFFE for Workload Identity — Integrating SPIFFE-based identities secures agent execution provenance, ensuring calls and attestations are tied to authorized workloads, enhancing trust.

• Cross-Platform Framework Integration — Catalyst plugs into popular agent frameworks like LangGraph, Microsoft Agent Framework, Google ADK, AWS Strands, OpenAI Agents SDK, and CrewAI, enabling wide applicability.

How It Works

Durable Execution: Keeping Work Alive

Durable execution ensures that an agent’s run state is checkpointed persistently. If the process crashes during complex workflows—such as a refund that requires multi-step verification—the system resumes at the last confirmed step instead of starting fresh. This eliminates wasted computation and inconsistent side effects like duplicate refunds.

This is achieved by capturing and persisting the state of each completed action, awaiting the next call or response. However, durable execution alone simply allows continuation, it does not faithfully record the exact decisions of the AI model made during a run.

The Missing Piece: Verifiability

Unlike deterministic code paths, AI agent decision-making can vary between runs due to model stochasticity or external data updates. This means simply replaying a run may not reproduce the exact decision path, which hurts auditability and accountability.

Verifiable execution records the entire run as an immutable ledger:

• Each Large Language Model (LLM) call and tool invocation includes input, output, and metadata.

• Every entry is cryptographically signed, ensuring its authenticity and protecting against tampering.

• The ordering and provenance of calls are recorded, making it possible for auditors to trace precisely why and how an agent reached a conclusion.

This audit trail serves as unforgeable proof, enabling compliance with regulatory mandates or internal governance requiring a "why" behind automated decisions.

Catalyst: Bridging Frameworks With Verifiable Durability

Catalyst takes existing agent frameworks—each with their own runtime semantics and APIs—and injects a transparent layer of durable, verifiable execution. This preserves developer workflows but adds:

• Declarative Workflow Engines support within agent runs without demanding separate external flow definitions.

• Workflow Attestation & Cryptographic Signing ensuring runs can be validated independently from the original actor.

• SPIFFE-based Identity Context, which guarantees workload authenticity during execution and verification phases.

As a package that plugs into frameworks like LangGraph and Microsoft Agent Framework, Catalyst enables enterprises to use AI agents in critical workloads without sacrificing trust or traceability.

// Example pseudocode for signing an agent step in Catalyst

async function processAgentStep(input) {
  const output = await callLLM(input);
  const signedRecord = await signStep({
    stepId: generateUUID(),
    input,
    output,
    timestamp: Date.now(),
  });
  await persistStepRecord(signedRecord);
  return output;
}

This cryptographic binding of inputs and outputs to steps creates the verifiable chain.

Quick Tips & Tricks

1. Leverage Durable Execution for Robust Agents — Always ensure your agent framework supports checkpointing or durable state persistence to prevent inconsistent side effects during transient failures.

2. Adopt Verifiable Execution for Auditing — If your AI system automates sensitive decisions, integrate cryptographic signing and attestation of agent runs to provide post hoc accountability.

3. Use SPIFFE for Workload Identity — Strengthen your system’s security posture by tying execution attestations to SPIFFE identities, eliminating ambiguity about run provenance.

4. Integrate Catalyst with Existing Agent Frameworks — Avoid costly rewrites by layering Catalyst on top of your current AI orchestration stacks for immediate verifiable durability benefits.

5. Record Inputs and Outputs at Every Step — Capture not just decisions but also all intermediate data traversing your workflows; it’s invaluable for debugging and compliance reviews.

6. Expect Non-Deterministic Paths in AI Agents — Accept that agents won’t always follow the same path even on identical inputs; verifiable execution helps explain these divergences post facto.

Conclusion

Durable execution has set the foundation for resilient AI agent workflows by allowing interrupted processes to continue where they left off. However, as agent autonomy grows, reproducibility diminishes, and traditional debugging becomes insufficient.

Verifiable execution complements durability by cryptographically recording every call and outcome in an auditable chain, returning trust and transparency to AI-driven processes. Catalyst’s approach—adding verifiable durable execution on top of existing agent frameworks—strikes a practical balance between flexibility and accountability.

As AI agents occupy increasingly sensitive and mission-critical roles, frameworks like Catalyst provide a blueprint for trusted automation that organizations can rely on for both operational continuity and regulatory compliance.

References

1. Durable Execution, Now Built for Agents - DEV Community — Original article discussing durable and verifiable execution concepts.

2. What is Agentic Durable Execution? - Diagrid Blog — Deep dive into Catalyst and agentic durable execution capabilities.

3. SPIFFE: Secure Production Identity Framework for Everyone — Industry standard for workload identity and attestation.

4. Microsoft Agent Framework — Example agent runtime integrated with Catalyst.

5. LangGraph Project — Agent orchestration framework supporting Catalyst.

6. OpenAI Agents SDK — Framework for building autonomous AI agents.

Google AI, a key AI platform partner referenced by Catalyst.

Neon provides robust database support suited for durable state management.

Algolia integration facilitates fast, reliable agent data retrieval and indexing.