You don't need to build a new reliability system for every AI Framework

AI products are built from a changing mix of agent frameworks, model SDKs, observability tools, sandboxes, and business services. Teams should be able to change those choices without rebuilding how their agents recover from failures, wait for people and systems, and resume from where they left off.

Today, we are making integrations for several popular AI libraries and agent frameworks generally available:

These integrations let developers run agents built with different frameworks in Temporal Workflows, with the same durable execution model across them. One Workflow can run a LangGraph graph, hand work to a Google ADK agent, and wait a week for a person to respond. If a model call fails, a Worker restarts, or a deployment interrupts the run, the application can continue from recorded progress.

Add durable execution without rebuilding your agent#

The integrations work with the agent code you already have. Add the Temporal package and the framework-specific imports, annotations, or integration points, and Temporal adds durable execution without requiring you to rewrite the agent.

With the Google ADK integration for Python, that looks like this:

from google.adk import Agent
from temporalio import workflow
from temporalio.google_adk import TemporalModel

@workflow.defn
class HelloWorldAgent:
    @workflow.run
    async def run(self, prompt: str) -> str:
        agent = Agent(
            name="Assistant",
            model=TemporalModel("gemini-2.5-flash"),
            instruction="You only respond in haikus.",
        )
        ...  # Run the agent with an ADK Runner, as usual.

Apart from TemporalModel, which takes the place of the model name, the code inside run is ordinary ADK code. TemporalModel runs each model call as an Activity, and registering GoogleAdkPlugin with the Temporal Client and Worker keeps the agent loop replay-safe.

The other integrations follow the conventions of their frameworks, including OpenAIAgentsPlugin for the OpenAI Agents SDK, TemporalAgent for Strands, and execute_in labels for LangGraph nodes.

What the integrations handle#

Separating coordination from external work. Workflows contain the long-lived coordination logic. Activities perform model calls, API requests, database access, and other side effects. Each integration maps framework behavior across that boundary so developers do not have to restructure their agents around Temporal.

Resuming from recorded progress. State that crosses the Workflow and Activity boundary is converted into a serializable form that Temporal can record and restore. After a Worker restart or deployment, Temporal reconstructs the Workflow from its Event History. During replay, previously recorded Activity results are reused rather than issuing the same model or tool call again.

Keeping production behavior consistent. The integrations turn off, or ask developers to turn off, framework-level retry loops so Temporal can manage retries and timeouts in one place. They keep clients and credentials on the Worker, carry trace context across processes, and prevent replay from exporting the same spans again after a restart.

Where supported, the integrations can also stream tokens through Workflow Streams, currently in Public Preview for Python and TypeScript. Agents can wait for human approval or other external input without polling or holding a Worker process open while they wait.

All of these integrations are built on Temporal’s Plugin API. Framework authors and partners can use the same extension model to bring durable execution to new tools as the AI stack changes. Partner-built integrations already include Pydantic AI, Mastra, and Braintrust.

Get started#

The GA integrations now live in the temporalio/ai-integrations repository, with a separate package for each integration and language. For instance:

# OpenAI Agents SDK for Python
uv add temporalio-openai-agents

# OpenAI Agents SDK for TypeScript
npm install @temporalio/openai-agents

# Google ADK for Go
go get go.temporal.io/googleadk

If you are upgrading from an earlier version, review the release notes before updating running Workflows. They identify package and import changes, breaking changes, and cases where Worker Versioning may be needed to let existing Workflows finish on an earlier integration version.

Start with the integration guides and runnable examples in the AI Cookbook. Framework authors can use the Plugin author guide to add support for other tools.