| TL;DR |
|---|
| Developers building AI agents can now get Durable Execution inside the platforms they already use, through Temporal’s work with NVIDIA, Google Cloud, AWS, Cursor, Lovable, MongoDB, Baseten, and others. The value of an agent comes down to how many steps it can take reliably. In production, those steps cross models, tools, data, compute, and people, and the more steps an agent takes, the more chances it has to fail. Temporal coordinates that work and holds onto its progress through crashes and long waits, so teams can trust agents with their longest-running, highest-value work. |
No single company builds the whole AI stack. Instead, developers do the hard work to assemble it from coding agents, frameworks, models, data platforms, sandboxes, and cloud infrastructure. They want to choose the right option at each layer and know their agents will hold up in production. That’s why NVIDIA, Google Cloud, AWS, Cursor, Lovable, MongoDB, Baseten, and more are building with Temporal. Together, we’re giving developers an open foundation for production AI, with Durable Execution running underneath whatever tools they pick.
Take a common scenario: you ask a coding agent to fix your bug. The agent then creates a branch, opens a pull request, waits for review, responds to feedback, runs tests, and merges the change. That one run can cross a model router, at least one model provider, a sandbox, a code host, a CI system, and human reviewers over hours or even days. The frustrating part is that each system can be reliable on its own and the run can still fail because progress gets lost in the handoffs between them.
Developers are already running into this. In Temporal’s 2026 State of Development survey of engineers and engineering leaders already working with AI agents, the share using agents daily or more rose from 47.3% to 80.8% in a year. And 41% of respondents hit problems with those agents at least daily, with tracking state named as the biggest blocker to using more of them.
Providing reliability is the job Temporal does in the AI stack. Temporal coordinates work across models, tools, data, compute and people, and Durable Execution keeps track of what’s finished and what’s still in flight, including steps that are waiting on a person. When something fails or pauses, the work resumes from its last completed step. We’ve done this in production for years for payments, orders, infrastructure provisioning, and data pipelines, and now our partners are building it into the AI platforms developers already use. The sections below show how those platforms work with Temporal and where to start.
Run durable agents on NVIDIA, Google Cloud, and AWS#
NVIDIA, Google Cloud, and AWS give developers the compute and agent tooling to build and run agents. Temporal plugs into each of them, so an agent built on the platform you’ve already chosen can run in production without your team building its own recovery layer.
With NVIDIA, Temporal is adding security and observability to agents, including in the physical world. With NeMo™ Relay, Temporal Workflows can observe and govern the work inside agent runs at each tool and model boundary. Temporal’s integration with OpenShell provides agent governance according to policies and high-security sandbox environments. And by integrating with solutions and agentic workflows built on NVIDIA Omniverse libraries and NVIDIA Isaac Sim open-source robotics simulation network, Temporal Workflows can perform physical AI tasks today, such as optimally laying out digital twins of factories. Together, Temporal and NVIDIA’s partnership is unlocking durable, secure, and observable agents for the real world.
“With NVIDIA software, Temporal is helping developers build agents that recover from failures and pause for human review, making agents collaborative teammates that help people get more work done.”
Adel El Hallak, VP of Product, NVIDIA
Google Cloud’s ADK and Gen AI SDK take developers from an agent definition to working code, and Cloud Run runs that code without servers to manage. Temporal integrates with both Google ADK and the Google Gen AI SDK, so an agent can still finish the job if it loses its container partway through a run or waits days for someone’s approval. In addition, our Serverless Workers integration with Cloud Run means there’s no Worker fleet to provision or leave idle while the agent waits.
“Developers shouldn’t have to rebuild Durable Execution to get agents into production. With Temporal and Google Cloud, they don’t have to.”
Sagar Randive, Product Manager, Serverless, Google Cloud
AWS offers developers Strands Agents for building agents on Amazon Bedrock models and AWS Lambda for running code on demand. With Temporal’s Strands integration, a crash or a failed call partway through a run doesn’t send the agent back to the start. Serverless Workers on AWS Lambda are invoked when there’s work and shut down when it’s done, so one long-running agent can span many invocations. And most recently, we added support for Amazon Bedrock AgentCore Runtime as a compute provider for Serverless Workers.
“Developers building agents on AWS want them to run reliably in production without paying for idle compute. With Temporal and AWS, agents built with Strands Agents keep their progress across model and tool calls. With Serverless Workers on AWS Lambda and Amazon Bedrock AgentCore, long-running agents can wait on approvals or other systems without keeping compute running.”
Shawn Henry, Sr. Technical Product Manager, AWS
Build durable apps and agents with Cursor, Lovable, and your agent framework#
Coding agents and AI-native app builders now write a growing share of the code that reaches production, so the patterns that make an app durable need to be there from the first prompt.
Cursor, now part of SpaceX Super Intelligence, takes developers from a prompt to working code, and its Marketplace adds specialized capabilities when a project calls for them. The Temporal plugin for Cursor brings Temporal’s development patterns into the coding agent, helping developers write deterministic Workflow code and run non-deterministic model and tool calls as Activities. Further, when a task calls for long-running, reliable execution, Cursor can recommend the plugin. Once a developer installs it, Cursor applies those patterns automatically. Temporal is a registered SpaceX Super Intelligence Marketplace Partner.
Lovable turns a plain-language description into a working full-stack app, and its users send a lot of messages along the way. Behind those messages, work like usage metering and billing has to be exactly right. Lovable runs that work on Temporal so users are billed accurately even when an outside service is having a bad day. That makes durability part of the product experience. You can keep the agent responsive and let a durable Workflow handle the work that can’t be wrong.
“Every message a user sends to Lovable kicks off work happening behind the scenes, like metering usage and deducting credits. Temporal makes sure that work completes correctly, even when a third-party system is slow or has an outage, so users are billed accurately every time.”
Jonathan Grahl, Team Lead, Infrastructure, Lovable
Agent frameworks face the same problem one layer down. Most agent loops keep their state in memory, so a crash or a redeploy partway through a run sends the work back to the beginning. The OpenAI Agents SDK and Pydantic AI give developers a compact way to define agents and the tools they call. Temporal’s integrations keep each framework’s programming model as is and run model and tool calls as Activities, so developers write the agent the way they already do and Temporal handles the crashes and the hours-long waits for a person’s input.
Run long agent loops on Baseten, Fireworks, Modal, and more#
A production agent rarely makes a single inference call. It assembles context, calls a model, invokes a tool, and decides what to do next, often dozens of times and across several models. The longer that loop runs, the more a single failure costs. An agent on its 30th model call shouldn’t repeat the first 29 because the 30th timed out, and a step that switches providers midway shouldn’t lose the context it already gathered.
Baseten and Fireworks serve open and custom models at production scale, and Temporal’s integrations with both make the application around those calls durable. Agents built with the OpenAI Agents SDK can run on the models either platform serves, and each model call runs as a Temporal Activity that’s retried with backoff and recorded, so the application can retry a timed-out or rate-limited call and keep the rest of its progress. One Worker can serve both providers at once, so teams can choose the model for each Workflow without changing how the application keeps its progress.
Sandbox providers such as Baseten and Modal give agents isolated environments to run code. Temporal’s Sandbox Orchestration Harness provides patterns for managing those environments for the length of an agent run, including preserving workspaces across pauses and restarts, so developers can carry an agent’s workspace forward without leaving idle containers running.
“Our customers build agents that make lots of calls to Baseten’s models and sandboxes in each run. With Temporal alongside us, they don’t need to hand-hold those runs anymore.”
Paul Sinaï, Head of Agent Infrastructure, Baseten
Evaluation and routing tools fit in the same way. Integrations with Braintrust, Langfuse, and Arize help developers trace and evaluate agent behavior. Gateways like OpenRouter let developers access many models and govern every request through one API. Temporal keeps the application’s progress around those calls, so teams can test a new model or compare results while their agents keep running.
Keep agent data available with MongoDB and Databricks#
Agents are only as good as the context they retrieve. The pipelines that keep that context current can fail quietly. For example, a dropped change raises no error, so the knowledge base drifts out of sync and agents answer from stale data. Temporal makes those pipelines durable, so a change that starts processing reaches the store even through failures and restarts.
MongoDB Atlas keeps operational data and vector search together on one platform, with embeddings and rerankers from Voyage AI for retrieval. In a reference architecture built with MongoDB, Temporal runs ingestion and the agent loop as Workflows. Ingestion starts directly from source events, so changes don’t get lost, and if a Worker fails mid-embedding, another one picks up the run without redoing finished steps. A zero-copy variant stores only references in Atlas for cases where sensitive text has to stay in the source system.
“Reliable agents need both trustworthy context and reliable execution, and MongoDB and Temporal address those complementary needs together.”
Melissa Plunkett, Vice President, Product at MongoDB
Databricks’ Lakebase Postgres gives agents an operational database for application state. In a reference implementation we built together, Temporal keeps Workflows running through restarts and unreliable downstream services, while Lakebase Postgres stores the evidence and review decisions behind each case. Agents can wait for a human reviewer or recover from a restart without losing access to that state.
Build on the Temporal AI Partner Ecosystem#
We’re building the Temporal AI Partner Ecosystem to give developers an open foundation for production AI. Developers can pick the tools that fit their application and get Durable Execution with every one of them without rebuilding it each time they add a new model or framework. As the AI stack keeps changing, we’ll keep deepening these partnerships and adding new ones.
If you’re building agents, the fastest way in is the Temporal Developer Skill, which brings Temporal’s patterns into the coding agent you already use. The resources below include the Durable AI docs, SDK integrations, and partner guides and reference implementations.
If you’re building an AI platform or developer tool, we’d love to work with you. Partners in the ecosystem give their developers durability out of the box, so more agents and applications built on their platforms make it to production. Partners also get in front of the hundreds of thousands of developers who build on Temporal every day. Get in touch with our partnerships team.
If you want to see it all in person, meet us at Replay 2027, Temporal’s developer conference, in San Francisco this spring. And if you’ve already shipped AI on Temporal, we’d love to hear your story from the stage. Visit the Replay website to submit a talk and check for registration updates.
Resources#
-
Google Cloud: Google ADK integration, Google Gen AI SDK integration, and Serverless Workers on Cloud Run
-
AWS: Strands Agents integration, Serverless Workers on AWS Lambda, and Serverless Workers on Amazon Bedrock AgentCore Runtime
-
Pydantic, Fireworks, Braintrust, Langfuse, Arize, OpenRouter, and many others: integrations directory
-
Temporal: Temporal Developer Skill, Durable AI docs, Sandbox Orchestration Harness, State of Development 2026


