By Temporal’s Replay 2026 conference this week closed out the company’s biggest operational gap: you no longer need to run a persistent worker fleet to use durable execution. Four features landed simultaneously — Serverless Workers on AWS Lambda, Workflow Streams for real-time agent output, External Storage for oversized payloads, and Nexus GA for Python. If you’ve been watching Temporal but avoiding it because of the infrastructure overhead, the calculus just changed.
The Worker Fleet Problem, Solved
Traditional Temporal workers are long-running processes. They spin up, connect to Temporal Cloud, and poll continuously for tasks. That model works well at scale, but it requires you to provision EC2 or ECS instances, configure autoscaling, manage worker health, and absorb idle compute costs when traffic is light. For teams experimenting with AI agents or running variable workloads, this was a real barrier.
Serverless Workers inverts this model. Instead of a process that polls indefinitely, Temporal invokes your Lambda function on demand when tasks arrive — the worker starts, processes available tasks, and exits. Temporal Cloud handles invocation, scaling, and graceful shutdown based on workload volume. You pay for what you use.
Setup is three steps: upload your worker code to AWS Lambda, create the cross-account IAM role using the Temporal-provided CloudFormation template, then register the Lambda function with Temporal via CLI or UI. Go, Python, and TypeScript SDKs are all supported. The feature is currently in Pre-release.
Crucially, your workflow and activity code does not change. The Temporal SDK works identically whether the worker runs on EC2 or Lambda. You’re changing the deployment target, not the programming model.
The LLM Payload Ceiling
If you’ve built a multi-turn AI agent on Temporal, you’ve likely hit the 2MB payload limit. Long conversation histories, tool call logs, and accumulated LLM context grow fast. Previously, teams worked around this with custom data converters — a poor experience requiring significant boilerplate.
External Storage, now in Public Preview for Python and Go, applies the claim check pattern: large payloads go to S3, and a small reference token passes through the workflow event history instead. Temporal includes a built-in S3 driver — no custom codec to write. For AI agent workflows that accumulate substantial context over many turns, this removes a hard architectural ceiling.
Streaming Tokens Without Sacrificing Durability
Streaming LLM output to a UI is straightforward with Server-Sent Events or WebSockets — until your agent crashes mid-stream and you lose track of where you were. Workflow Streams solves this by building a durable streaming layer on Temporal’s existing Signal and Update primitives.
Signals carry published events asynchronously. Updates serve long-poll subscriptions synchronously. Together they create an offset-addressed event channel that survives worker restarts and Continue-As-New boundaries. A subscriber reconnecting after a crash picks up exactly where it left off. The Python SDK contrib library is available now, and there’s no separate infrastructure to operate.
Nexus GA and Service Boundaries
Nexus — Temporal’s mechanism for durable service-to-service calls across namespaces — reached GA for the Python SDK at Replay 2026. TypeScript and .NET are in Public Preview. Nexus exposes clean service contracts through Nexus Endpoints implemented in standard Temporal workers. Cross-cluster replication is not supported yet for self-hosted deployments, but Temporal Cloud supports Nexus connectivity within and across regions.
Why This Matters Now
Temporal has 3,000+ paying customers and raised $300M at a $5B valuation in February, but the more significant signal is ecosystem convergence. LangGraph, Pydantic AI, the OpenAI Agents SDK, and Google ADK have all added Temporal integrations. When every major AI framework points at the same infrastructure layer, that is not coincidence — it is a consensus forming around durable execution as the default primitive for production AI agents.
The argument for Temporal over message queues was always sound: SQS and RabbitMQ move messages; they do not track workflow state. When an AI agent running for four hours crashes, a queue loses all context. Temporal’s event-sourced history means resuming from the exact failure point, on any worker, days later. The Replay 2026 announcements do not change that argument — they remove the operational excuses for not acting on it.
Full details on all four features are in the official Replay 2026 announcement. The combination of serverless workers, S3-backed storage, durable streaming, and expanding Nexus SDK support suggests Temporal is actively closing the gap between “works in production” and “we can actually ship this.” Coverage from The New Stack has additional context on the serverless workers architecture.
