August 2026 Summaries

Temporal has announced two Google Cloud-focused updates intended to improve the reliability and procurement of AI agent workflows. Its Google Gen AI Python SDK integration, now in public preview, adds durable execution to Gemini-based applications so content generation, function calls, and chat sessions can recover from crashes, timeouts, and restarts without losing workflow progress or duplicating work. The release builds on Temporal’s existing Google ADK integration for durable agent orchestration and its pre-release serverless worker support for Cloud Run. Separately, Temporal Cloud is now available through Google Cloud Marketplace on a pay-as-you-go basis, allowing Google Cloud customers to use consolidated billing, potentially apply existing committed cloud spend, and receive $1,000 in automatic onboarding credits. The marketplace offering is designed to shorten vendor onboarding and reduce administrative overhead for organizations already operating on Google Cloud.

Temporal’s monthly update introduces serverless Workers for AWS Lambda in public preview, enabling Cloud customers to run Worker code with automatic scaling, observability, and no idle infrastructure costs, alongside pre-release Projects for organizing Cloud resources and permissions. New Durable Execution features include standalone Nexus Operations, Google GenAI and LangChain Deep Agents integrations, Activity Operations for intervening in individual tasks, and Workflow Pause for safely halting and resuming running processes. Worker Performance poller autoscaling and Nexus support for .NET and TypeScript have reached general availability, while new tutorials and validated patterns cover durable job queues, specialized workload routing, and business-process recovery. The update also highlights a ticket-monitoring application built with Temporal Serverless Workers on Google Cloud Run, a new news feed in the Temporal Web UI, community discussions that led to an SDK bug fix, findings from the 2026 State of Development Report on growing AI-agent use and reliability challenges, and several upcoming community events.

Effective use of coding agents for Temporal applications depends less on the chosen AI tool than on supplying reliable context, enforcing quality controls, and agreeing on a clear plan before implementation. The recommended foundation combines the Temporal Developer Skill for vetted guidance, official SDK sample repositories for executable feature-specific patterns, and the Temporal Knowledge Base MCP server for cited answers drawn from documentation and expert resources. Agents should be constrained through test-first development, including isolated Activity, mocked Workflow, integration, Signal, and replay tests, alongside linters, formatters, strict type checking, and direct use of the Temporal CLI to run workflows locally and inspect Event Histories. Detailed, scalable specifications help resolve key architectural decisions such as Workflow versus Activity boundaries, Signals versus Updates, Child Workflows versus Nexus, event-history limits, and Continue-As-New needs. When an agent makes an error, the approach advocates identifying missing context or guardrails, recording the lesson in project instructions or reusable skills, and continually improving those resources. This treats AI agents much like new engineering team members that require onboarding, trusted references, design documents, code review mechanisms, and operational validation, while keeping human engineers responsible for the underlying decisions.

Temporal introduces the Temporal Agent Harness, an early-stage open-source framework designed to add durable execution, governance, and observability around existing AI agent SDKs rather than replace them. It addresses the challenge of using unpredictable language models in business processes by running agents as Temporal Workflows that can survive failures, wait for approvals or external events, retry work, and resume without repeating completed steps. The harness currently integrates with Google Gemini, OpenAI Agents SDK, and PydanticAI, and provides controls around tool calls, including configurable approval policies, while supporting long-running interactions through a higher-level “turn” model that preserves context across multiple agent invocations. It also enables strongly typed agent operations and composition between agents, supports policy-governed code execution and remotely performed callback tools, and records execution as a durable stream of structured AgentEvents for interfaces, audits, debugging, analytics, evaluation, and replay. Temporal describes the project as earlier than a public preview, with changing APIs and unfinished abstractions, and invites developers to test it, contribute feedback, and suggest integrations and additional SDK support.

AWS provides components for agentic AI development, including Amazon Bedrock for governed access to foundation models, the open-source Strands Agents SDK for model-driven agent workflows, and Lambda or Bedrock AgentCore Runtime for scalable compute. Temporal is presented as a complementary orchestration and durability layer that records agent actions, supports retries and recovery after failures, and preserves state during long-running processes or human approval delays. Its Strands integration routes model, tool, and MCP calls through Temporal Activities while retaining compatibility with existing Strands agents, and its Serverless Workers can invoke Lambda only when task-queue work is available, avoiding continuously running workers. A loan-underwriting demonstration illustrates the approach: Strands coordinates applicant-data gathering and risk assessment, Bedrock supplies model reasoning, Lambda provides elastic execution, and Temporal enables the workflow to recover from crashes and wait for human decisions without losing application progress.

A project aimed at converting STL meshes into genuinely editable CAD models found that AI agents and durable orchestration were less valuable than rigorous geometric validation. The desired output was not merely a valid STEP file, but a clean solid with recognizable planes, cylinders, holes, seams, and other editable features rather than thousands of triangular faces. Although AI assisted with API exploration, strategy development, and experiments, agent-driven planning proved unreliable because plausible reasoning did not guarantee accurate geometry. The converter instead evolved around generating multiple candidates, writing and rereading STEP files, performing BRep and deviation checks, and selecting only outputs that met measures for validity, analytic surfaces, face economy, feature semantics, seam quality, and fidelity to the source mesh. Several proposed improvements were discarded after measurements showed little or no benefit, reinforcing a test-driven approach over preserving ambitious agent architecture. Fusion’s mesh conversion tools, particularly its Prismatic method, were added as an optional candidate backend because they can infer CAD-like surfaces from grouped mesh faces, but not as an authoritative replacement for independent validation.

HeyGen replaced a custom video-generation orchestration system built on MySQL, RabbitMQ, Celery, polling, and callbacks with Temporal to improve reliability, recovery, and development speed across a complex pipeline involving speech generation, GPU avatar inference, rendering, compositing, billing, and delivery. Temporal workflows durably coordinate sequential and parallel activities, retries, compensation such as quota refunds, and recovery from worker failures, while concurrent scene processing uses stage-specific limits and selectively applies child workflows for isolated timeout or failure boundaries. At scale, the platform manages millions of workflow executions and tens of millions of activities daily through roughly 300 workflow types, nearly 1,000 activities, about 100 task queues, and more than 50 independently scaled worker deployments across multiple GPU providers. HeyGen also built shared tooling for identity propagation, retry policies, metrics, visibility, heartbeats, worker setup, and deterministic workflow testing, alongside admission controls and task priorities that enforce customer fairness. To control GPU costs and capacity, it uses workload-specific queues, a Temporal-based global autoscaling coordinator that accounts for worker readiness, demand, provider cost, and allocation priorities, plus a custom slot mechanism that overlaps input preparation with inference without allowing concurrent GPU use.

MongoDB Atlas and Temporal are presented as complementary platforms for moving retrieval-augmented generation and agentic AI systems from demonstrations to reliable production deployments. Atlas centralizes operational data, embeddings, vector search, reranking, and potential agent memory, while Temporal’s Durable Execution manages long-running ingestion pipelines and agent workflows by preserving state, retrying failed operations, and resuming work after crashes or infrastructure interruptions. The reference architecture ingests content such as Temporal documentation through source-triggered, idempotent workflows that fetch, chunk, embed with Voyage AI, and index data in Atlas, supporting both bulk backfills and incremental updates without requiring Kafka for durable buffering. A research agent then searches and reranks the same Atlas-hosted content, using Temporal to make its multi-step reasoning, tool calls, progress reporting, and audit trail resilient and observable. The proposed pattern emphasizes consistent retrieval data, scalable parallel embedding, framework flexibility for agents, and reduced infrastructure complexity, while noting current limitations including limited use of long-term agent memory, unbatched embedding calls, and the absence of token-level streaming in the interface.

Houman Kargaran describes a PII-compliant RAG pipeline orchestrated with Temporal, extending an earlier ingestion stage in which complaint redaction, classification, and storage remain within a single Activity and only a non-sensitive file ID proceeds through the workflow. The ComplaintWorkflow sequences separate, retryable Activities to generate on-premises embeddings with the all-MiniLM-L6-v2 model, cache vectors in Redis, upsert them into Pinecone, mark successfully stored PostgreSQL records as embedded, perform a lightweight vector-query smoke test, and delete the temporary cache. Redis functions as external payload storage, similar to the Claim Check pattern, so Temporal passes only small references rather than vectors or PII. Provider interfaces allow embedding and storage implementations to be replaced independently, although changing models may require index changes and re-embedding. Reliability is supported by stable case IDs, duplicate-safe PostgreSQL inserts, Pinecone upserts, and an embedded flag that enables reconciliation and selective reruns, while Temporal provides durable orchestration and retry behavior. Although vectors originate only from redacted text, the approach treats embeddings as sensitive application data and removes cached copies after the workflow completes.

Temporal’s UserMetadata features improve observability for agentic workflows by adding meaningful labels to reusable Activities, Workflows, and Timers without requiring custom activity names. Using a coding-agent example that repeatedly plans changes, edits files, runs tests, evaluates results, and waits for CI, the post shows how Activity summaries make Temporal’s Timeline and Compact History views easier to scan and diagnose, especially when workflows fail or follow adaptive recovery paths. Workflow metadata includes immutable static summaries for short labels, immutable static details for larger startup information such as model settings and task configuration, and mutable current details for reporting a workflow’s live progress while it is running. Timer summaries can similarly explain why a workflow is paused, such as waiting for CI results. These metadata capabilities are available across Temporal’s Go, Python, TypeScript, Java, .NET, PHP, and Ruby SDKs.

Xgrid describes rebuilding construction and facilities field operations on Temporal by treating each worker shift as a single durable workflow rather than relying on fragile, loosely coordinated services. The approach uses deterministic workflow IDs, updates and signals, in-workflow queues, state-machine validation, and durable event histories to ensure clock-ins, clock-outs, reports, tool tracking, and document signatures remain ordered, idempotent, auditable, and recoverable despite offline devices, duplicate requests, system outages, and worker-process redeployments. BLE beacons replaced unreliable GPS for site verification, while device-captured timestamps preserve when workers actually acted rather than when delayed requests reached the server. Temporal Cloud provides orchestration while client-side encryption keeps sensitive data encrypted, and its task queues allow a small worker cluster to absorb large clock-in spikes without losing work. Durable workflows and schedules also support retried daily reports, real-time operational dashboards, historical analysis, and faster troubleshooting; Xgrid reports payroll accuracy rising above 99%, near-zero tool losses, on-demand audit preparation, and field-issue diagnosis falling from hours to minutes.

Temporal migrated its metering and billing read paths from a previous warehouse to ClickHouse to address limited growth capacity, costly scheduled deduplication, and delayed customer usage data, while leaving ingestion and streaming infrastructure unchanged. Because the at-least-once delivery pipeline intentionally creates duplicate events and billing inaccuracies can directly affect invoices, the team shadowed both databases for six weeks, serving customers from the legacy system while comparing production-scale results in the background. They defined tolerated floating-point variation, distinguished expected freshness differences caused by ClickHouse’s read-time deduplication, and treated implausible results as blocking defects; this process exposed a 64-bit integer overflow that produced negative usage totals for large accounts. The rollout proceeded in reverse data-flow order, moving reversible customer-facing read APIs before the harder-to-reverse billing aggregation path, with per-account flags enabling rollback. The migration increased projected capacity headroom from about one year to three to five years, reduced steady-state costs by roughly 70%, improved query performance, eliminated a batch dependency and its operational burden, and made usage data available to customers around 30 minutes sooner.

A software engineer describes the difficulty of connecting cloud applications reliably to firewalled on-premises edge systems, drawing on a warehouse-automation project that required extensive custom bidirectional messaging, retry logic, testing, customer deployments, and coordination with remote network teams. To address these challenges, the author built an open-source, egress-only proxy using Temporal as a durable orchestration layer, replacing traditional queues, polling mechanisms, and hand-built failure handling. The proxy maintains a single outbound connection to Temporal, which also serves as a control channel for remotely updating and hot-reloading configuration without restarts, redeployments, or inbound firewall rules. Although the solution has been tested only with local, cloud, and simulated environments rather than production deployments, the author presents it as a reusable pattern intended to improve reliability, visibility, remote management, and message durability for cloud-to-edge integrations.

A demonstration called Ziggy’s Ice Cream models a multi-agent delivery fleet using Google ADK, LangGraph, or both together, with Temporal providing durable orchestration across agent reasoning, tool calls, driver operations, and human decisions. Fleet and customer agents can assess orders in parallel while a dispatch agent makes assignment decisions, illustrating ADK’s agent-team composition and LangGraph’s explicit graph-based control flow, including interruptions for human review. The system treats human input as an asynchronous, durable interaction delivered through Temporal Signals, allowing workflows to pause for hours or days without consuming compute and to survive worker crashes, deployments, or evictions. Temporal records workflow events and activities for retries, replay, auditing, and cross-framework coordination, though in-flight model calls may need to restart after failures and side-effecting tools require idempotency safeguards. The example also highlights operational concerns such as separating task queues to prevent model inference from delaying driver work and using continue-as-new to limit event-history growth for long-running workflows.

HeyGen replaced a custom video-generation orchestration system based on MySQL, RabbitMQ, Celery, polling, and callbacks with Temporal to improve reliability, recovery, and development speed across complex media and AI workflows. Temporal now coordinates millions of daily workflow executions involving speech generation, scene preparation, GPU avatar inference, rendering, compositing, billing, progress reporting, and failure compensation, while persisting workflow history so work can resume after worker failures without manual reconciliation. The company models end-to-end videos as workflows containing activities, runs scene processing concurrently with stage-specific limits, and uses child workflows only where separate timeout or failure boundaries are useful. HeyGen also built a shared platform for reusable workflow modules, consistent retries, identity propagation, metrics, search metadata, heartbeats, worker scaffolding, and deterministic-code checks. To manage heterogeneous GPU infrastructure across Kubernetes and serverless providers, it applies customer-level admission controls and task priorities, operates workload-specific queues and workers, and uses Temporal-based global autoscaling workflows to allocate capacity according to readiness, demand, cost, and provider preference. Additional worker-slot controls overlap input downloads with GPU inference while ensuring only one task uses a GPU at a time, improving utilization without distorting performance metrics.

In a guest post by Houman Kargaran, the engineering lead at ANZ Bank, the focus is on a compliance-driven architectural decision within a data processing workflow that involves scanning, classifying, and storing personally identifiable information (PII) in a single Temporal Activity to meet strict regulatory requirements. Despite Temporal's preference for small, single-purpose activities, this approach is justified by the need to keep sensitive data within a single Activity to prevent it from being exposed in the Temporal UI. The workflow utilizes an in-house MCP server for PII checks and an internal ML model for classification, ensuring PII is redacted before processing. The architecture also employs a DataStore protocol to allow flexibility in storage backend choices without altering business logic, and it uses heartbeating to maintain workflow reliability, enabling detection and recovery from worker failures. This strategic design ensures that raw data does not cross Activity boundaries, maintaining data privacy and security throughout the process.

A Temporal developer advocate built a WhatsApp and Telegram chatbot for San Francisco Unicorns cricket fans, designed to answer questions, provide grounded live scores and news, send match reminders, support predictions, and direct users to tickets and merchandise. The bot uses Gemini for conversational responses while relying on live data tools for factual information, with four Temporal Workflows managing conversations, durable reminders, minute-by-minute score subscriptions, and post-match summaries so tasks can continue through Worker failures. Building for WhatsApp required handling its 24-hour messaging restrictions, approved templates, signed and duplicate webhooks, button limits, and fixed webhook endpoints, while WhatsApp ultimately accounted for about 97% of sign-ups. During an early match, a faulty budget guard based on an outdated API free-tier limit stopped score refreshes and caused the bot to report stale results confidently, revealing that durable infrastructure cannot prevent application-logic errors but can provide replayable execution records for diagnosis. After testing and launch support from the team, fan activity grew around match days, with users returning for player questions, reminders, live updates, and prediction competitions, illustrating how durable workflow systems can support long-running, failure-tolerant interactions beyond sports bots.

In preparation for a conference, a team at Temporal undertook the massive task of flashing firmware onto 2,300 badges using a system named Ignition, which was powered by Temporal's framework. The process involved utilizing lazy Susans as makeshift carriers for USB hubs, allowing for efficient loading and rotation of badges. Each badge was flashed using Ignition, which coordinated retries, logged processes, and validated successful firmware installation. The project required managing USB enumeration challenges and ensuring the correct firmware booting process, all within a tight deadline dictated by the conference schedule. The team operated six stations with independent Temporal servers to avoid central failures and relied on a coordinated assembly line effort involving over 70 coworkers. This approach enabled them to manage the complex logistics of the hardware assembly and flashing process without a centralized dependency, highlighting the significance of Temporal's workflow management in transforming what could have been an overwhelming task into a successful and collaborative operation.

Deputy is an open-source, CLI-first security toolchain designed to address the challenges faced by security engineers in managing vulnerabilities across a range of targets, including repositories, container images, and VM disk images. Developed by Temporal's Security team, Deputy provides a customizable policy layer to help security teams and developers inventory, scan, triage, and control dependencies effectively. It integrates with existing systems and uses a plugin system for extensibility, offering features like deterministic supply chain analysis and execution guardrails for AI-assisted work. Deputy's policy system, written in YAML using the Common Expression Language (CEL), enables precise decision-making regarding vulnerabilities and dependencies, with policies applicable across local development, CI, and download times. Although it is still in its early stages of development, Deputy aims to provide a better signal for vulnerability management and is designed to be integrated seamlessly into existing workflows, emphasizing the importance of context and nuanced understanding in security management. The tool is freely available under the Apache 2.0 license and encourages contributions from the community to further enhance its capabilities.