TechPrufer
Get started
Temporal
Temporal logoTemporal · Feature trail

AI-Assisted Code Migration

3 posts · Dec 2024 – Sep 2026

What this trail covers

Temporal provides a robust foundation for Agentic AI workflows, offering durability, scalability, and flexibility. This includes features like scheduled execution, human-in-the-loop support, and multi-language integration. The platform acts as a centralized orchestrator for coordinating API calls, services, and data sources, enabling complex, long-running AI agents that can persist and evolve. This post details practices for using coding agents effectively during migrations, focusing on cleanup, and introduces a dedicated PM role to optimize AI coding assistants for Temporal.

All Temporal trails
  1. Using coding agents on a migration: Three practices that matteredThis post details three practices that improved the effectiveness of coding agents during a migration: 1. Writing cleanup instructions alongside temporary code to create a deletion checklist. 2. Placing durable rules next to the code they govern, with clear enforcement mechanisms (e.g., regression tests). 3. Treating agent instructions as artifacts that can become stale and require maintenance, similar to code documentation. The post emphasizes that these practices are most beneficial for cleanup tasks and that the agents' effectiveness is amplified by existing engineering habits.
  2. Everything in its place: Making agents write correct Temporal applicationsThis post details how to effectively use AI coding agents to write Temporal applications by providing them with the right context. It introduces three key resources: the Temporal Developer Skill for curated patterns, SDK samples repositories for executable code examples, and the Temporal Knowledge Base MCP server for deep, cited answers. The author emphasizes manually invoking skills, explicitly referencing sample repositories, and leaning on the MCP for design validation to prevent architectural mistakes and improve code quality.
  3. The “cool new stuff” trapThis post details the author's experience using an AI agent with Temporal's Durable Execution for a complex geometric conversion task (STL to editable CAD). It highlights a key learning: the 'trap' of assuming AI autonomy would solve the core problem. Instead, the project's success was driven by a rigorous validation and measurement system that evaluated candidate outputs against concrete metrics (BRep checks, face counts, analytic surfaces, editability score). The post contrasts this empirical approach with the perceived 'cleverness' of AI planning, emphasizing that for certain domains, robust validation and iterative refinement are more critical than advanced agentic reasoning. It also touches upon using Fusion as an optional candidate backend, further reinforcing the theme of empirical evaluation.
  4. Durable, flexible multi-agent systemsThis post details the implementation of a multi-agent system for fleet delivery, demonstrating cross-framework orchestration between Google ADK and LangGraph using Temporal. It showcases how Temporal's Durable Execution provides a reliable foundation for agent loops, handling model and tool calls as Activities. Specific contributions include: 1. Cross-framework orchestration example using child Workflows for ADK and LangGraph components. 2. Implementation of human-in-the-loop patterns, treating human interaction as a durable Signal-based API. 3. Use of `workflow.wait_condition` with durable Timers for long-waiting processes. 4. Application of Continue-as-New to manage growing Event History for long-running driver loops. 5. Separation of Task Queues for agent reasoning and driver Activities to prevent starvation.
  5. LangGraph in production: Temporal's LangGraph Plugin adds Durable ExecutionThis post introduces a new LangGraph integration for Temporal Python SDK and LangSmith integrations for Python and TypeScript. The LangGraph integration allows LangGraph agents to run as Temporal Workflows, with nodes executing as Activities, providing durable execution, automatic failure recovery, and cost-effective human-in-the-loop steps. The LangSmith integration propagates trace context across Temporal boundaries for unified observability of durable agent runs. The post details how LangGraph's checkpointing is enhanced by Temporal's durable execution, how `interrupt()` is handled with durable waits, and how long-running agents benefit from Temporal's state and execution persistence.
  7. Diving into the AI iceberg: What lies beneath your AI agentsThis post details the integration of Temporal, Neo4j, Auth0, and Redpanda to create a full-stack Deep Research Agent. Temporal orchestrates the multi-agent workflow, handling coordination, human-in-the-loop pauses, parallel execution, automatic retries, and durable execution. The post includes a simplified Python code example of the Temporal workflow definition. Neo4j is used for knowledge graph and memory persistence, Auth0 for user authentication and API/tool protection, and Redpanda for streaming workflow events.
  8. How Coverwatch uses Temporal to orchestrate AI-powered insurance workflowsThis post details how Coverwatch uses Temporal to orchestrate AI-powered insurance workflows, combining AI agents, human review, and carrier communication. It highlights the use of Temporal Signals for human-in-the-loop automation and workflow history as a debugging asset for AI agents. The post emphasizes that durable execution is the right foundation for agentic insurance workflows, and that startups can skip the orchestration infrastructure tax by using Temporal Cloud.
  9. How to build deep research agents using Temporal and BraintrustThis post details the integration of Temporal Workflows with Braintrust to build resilient and improvable deep research agents. It maps each agent to a Temporal Activity, leveraging Durable Execution for retries and timeouts, and implements parallel execution with graceful degradation for web searches. Key design decisions include using Pydantic models for structured data contracts and configuring `start_to_close_timeout` for LLM API calls. Braintrust's `BraintrustPlugin` is integrated to capture end-to-end execution graphs, enabling tracing of agent interactions and LLM calls for observability and evaluation.
  10. What does it take to build a customer support experience your users won't hate? Ask Bitovi.This post details the integration of AWS Bedrock AgentCore Memory into an existing Temporal Workflow for an AI customer support agent. It highlights how AgentCore's semantic memory, user preference memory, and session summaries were plugged in as a Temporal Activity, allowing for memory persistence across sessions without re-architecting the core Workflow. The post also emphasizes the importance of distinguishing between retry logic and true resilience, and the deliberate use of a small buffer of raw conversation in Workflow State to bridge the gap during AgentCore's memory extraction.
  11. From agent zoo to agent orchestra: The benefits of Temporal as your enterprise agentic control planeThis post details how Temporal serves as an enterprise agentic control plane, addressing the challenges of deploying AI agents in production. It categorizes agents into Conversational, Event Stream Processors, Ambient, and Agent-to-Agent interactions, highlighting their distinct architectural needs. The post emphasizes Temporal's role in providing essential features for agentic platforms: guardrails (approval gates, timeouts), handling conflicting agents (workflow isolation, idempotency), data security (namespace/process isolation, audit trails), and orchestration. It introduces Temporal Nexus as a mechanism for inter-agent communication and coordination across namespaces, acting as a switchboard for agentic services. Workflow Versioning is presented as a critical capability for managing changes in long-lived agent workflows without disrupting in-flight executions. The post also touches upon operational realities like LLM cost management and retry policies.
  12. How XY builds an AI agent orchestration platform for healthcare with TemporalThis post details how XY built an AI agent orchestration platform for healthcare using Temporal. Key contributions include: a YAML-based DSL for defining complex workflows, a single generic `DSLWorkflow` class to interpret this DSL, an AI Planner Agent that translates natural language into executable YAML, an Activity Factory for runtime assembly of customer-specific integrations, and a deferred continue-as-new mechanism for infinite batch processing. The post also highlights infrastructure patterns for precise scaling based on workload types and the benefits of Temporal's vocabulary for aligning engineering and product teams.
  13. What agentic AI borrowed from microservices (and made worse)This post draws parallels between microservices and agentic AI architectures, highlighting how the industry is re-solving similar problems. It details the decomposition of monolithic agents into microagents, analogous to microservices, to manage complexity and improve LLM performance. It also discusses the shift from request/response to event-driven architectures for agents, emphasizing Temporal's role in providing durable execution for long-running agent workflows and managing agent memory through an event-sourcing-like model that prevents re-execution of side-effecting operations.
  14. Introducing the Temporal Developer SkillThis post introduces the Temporal Developer Skill, a new feature that provides authoritative, distilled Temporal development guidance directly to AI coding agents. The Skill covers Workflow determinism rules, Activity patterns, retry policies, error handling, testing strategies, Worker configuration, versioning, and common gotchas. It is language-agnostic for 80% of its content and currently supports Python, TypeScript, and Go, with more languages to follow. The goal is to improve the quality of AI-generated Temporal code.
  15. Trusting AI agents: A reinsurance case studyThis post details the implementation of a multi-agent system for reinsurance data processing using Temporal Workflows and Activities. It introduces a 'Bridge Workflow' for orchestrating multiple 'Agent Workflows' and managing inter-agent data passing. Human-in-the-loop confirmation for tool execution and agent completion is implemented using Temporal Signals. The system demonstrates modular agent design, with each agent focusing on a specific task and using LLMs for decision-making and data extraction. Tools are implemented as Temporal Activities, and agents-as-tools are implemented as separate Agent Workflows. The post highlights design principles for building trustworthy AI agents, including human-in-the-loop, modularity, and simplified tool arguments.
  16. Building durable agents with Temporal and AI SDK by VercelIntroduces a new integration for the AI SDK by Vercel, enabling Durable Execution for AI agents. This integration wraps LLM calls and tool executions within Temporal Activities, providing automatic retries, state management, and guaranteed completion for AI workflows. The post demonstrates how to configure the Temporal Worker with the AiSDKPlugin and use `temporalProvider.languageModel()` in Workflow code. It also details how to proxy tool functions as Temporal Activities for durable execution. A real-world example of a daily news briefing agent is provided, showcasing the seamless addition of durability to existing AI SDK code.
  17. The scientific response to vibe coding - Why we're hiring an Agentic Coding PMThis post introduces a new dedicated Product Manager role focused on improving AI coding assistants' performance with Temporal. It outlines the creation of a benchmark suite for measuring LLM coding assistant performance on Temporal tasks, the development and validation of assets (agents.md, Cursor rules, Claude skills, etc.) to improve output quality, and closing the feedback loop between developer struggles and platform fixes. The role prioritizes AI coding tool proficiency, analytical thinking, and product management fundamentals.
  18. The hero’s journey to AI durability with TemporalThis post details patterns for achieving AI durability using Temporal, specifically focusing on: 1. Wrapping LLM calls and other side effects (like PDF generation) in Temporal Activities to prevent duplicate work upon system restarts. 2. Using Temporal Signals and Queries to implement human-in-the-loop workflows, allowing for asynchronous feedback and state management. 3. Orchestrating AI agent tool execution by wrapping MCP tool calls in Temporal Activities and chaining them within Workflows to ensure durability and state persistence across restarts. It also emphasizes using Temporal timers for durable waits within Workflows.
  19. Of course you can build dynamic AI agents with TemporalThis post clarifies the distinction between deterministic Workflow code and non-deterministic Activity execution in Temporal, explaining how this separation enables the creation of durable and dynamic AI agents. It debunks the myth that Temporal's determinism requirement prevents its use for AI agents, highlighting that the Workflow replays past LLM decisions from the Event History upon recovery, allowing the agent to dynamically plan its next steps without re-executing costly LLM calls or introducing inconsistencies. The post provides code examples illustrating this pattern and references OpenAI's Codex and Replit's Agent 3 as production use cases.
  20. Here's how to build durable AI agents with Pydantic and TemporalThis post introduces native Temporal support within the Pydantic AI framework. It details how Pydantic AI agents, which are inherently non-deterministic due to external API calls, can be wrapped with `TemporalAgent` to leverage Temporal's durable execution. This integration automatically offloads non-deterministic work (model calls, tool executions, external API calls) to Temporal Activities with built-in retry policies, while the agent's coordination logic runs deterministically as a Workflow. The post provides code examples for integrating a single agent and orchestrating multiple agents (dispatcher and researcher) within a Temporal Workflow for a Slack bot use case, highlighting fault tolerance, state preservation, and handling of human-in-the-loop interactions.
  21. How to think about agentic solutions for the enterpriseThis post introduces the concept of Durable Execution as a critical missing component for enterprise-grade AI solutions, contrasting it with the limitations of current AI frameworks and agent prototypes. It highlights the challenges of moving AI agents from experimentation to production, focusing on reliability, observability, and scalability. The post emphasizes that Temporal's Durable Execution provides the necessary backbone for state tracking, failure handling, recovery, and visibility required for production AI systems, citing examples of companies that have successfully adopted this approach. It also discusses the 'hidden tax' of fragile AI, including time and revenue losses due to reliability issues and LLM inconsistencies.
  22. From prototype to production-ready agentic AI solution: A use case from Grid DynamicsThis post details a migration from a LangGraph-based deep research agent to Temporal. Key technical contributions include: 1. Demonstrating state management transformation by making state an integral part of the Temporal Workflow class, eliminating the need for external state stores like Redis and enabling automatic, durable persistence in Temporal's event history. 2. Simplifying error handling and retry logic by replacing thousands of lines of custom try-catch blocks and retry loops with declarative `RetryPolicy` configurations attached to Activity executions. 3. Highlighting the elimination of custom workflow orchestration and retry logic, and the resolution of 'exactly once' challenges previously faced with Apache Kafka by leveraging Temporal's built-in durability and state management.
  23. Orchestrating ambient agents with TemporalThis post details how Temporal primitives (Workflows, Signals, Queries) can be used as durable "tools" for AI agents within the Model Context Protocol (MCP) framework. It demonstrates using Temporal Schedules to trigger proactive "nudge" Workflows every few seconds for ambient agents, and Signals/Queries for inter-agent communication (e.g., judge agent signaling execution agent with updated prompts). The Temporal UI is highlighted for observing agent interactions and providing auditability. The post also emphasizes Temporal Workflows as a central orchestrator for modular, 24x7 agent coordination, ensuring fault tolerance and deterministic replayability. The core contribution is the practical application of Temporal's scheduling, communication, and orchestration features to build a complex, multi-agent AI system like a crypto trading platform.
  24. Durable multi-agentic AI architecture with TemporalThis post introduces and details patterns for multi-agent orchestration using Temporal, specifically focusing on agent routing and task delegation. It provides a concrete example of a detection and repair system for order management, showcasing how Temporal Workflows can orchestrate AI agents for analysis, plan creation, and plan execution. It also demonstrates integrating these agents with conversational interfaces via MCP (Model Context Protocol) and highlights the durability and resilience benefits of using Temporal for these complex AI workflows.
  25. Building long-running interactive MCP tools with TemporalThis post details how to build long-running, interactive MCP tools by integrating Temporal Workflows with MCP hosts and clients. It introduces the Temporal Invoice MCP sample, demonstrating how Temporal Workflows can orchestrate complex, multi-step processes with human-in-the-loop interactions. The sample showcases using Temporal Workflows to trigger, check status, approve, and reject invoice processing. It highlights the use of Signals, Queries, and Updates for interacting with long-running agentic AI tools, enabling durable execution for agentic AI systems.
  26. Production-ready agents with the OpenAI Agents SDK + TemporalThis post details the integration of the OpenAI Agents SDK with Temporal's Python SDK, enabling durable execution for AI agents. It highlights how Temporal's features like automatic retries, crash-proof execution, and state persistence address production challenges such as rate-limited LLMs and network connectivity issues. The integration allows developers to define agents using the OpenAI SDK and leverage Temporal Workflows and Activities for orchestration, without significant code complexity. The post introduces the concept of agents and handoffs from the OpenAI SDK and maps them to Temporal's Workflows and Activities, demonstrating how to run agents and orchestrate them within a Temporal Workflow.
  27. Building production-ready generative AI: How Temporal supercharges Google's Gemini and VeoThis post details how Temporal supercharges generative AI systems like Google's Gemini and Veo by providing a resilient and observable platform for complex, long-running AI workflows. It highlights how Temporal handles state persistence, transient failures, costly re-runs, and provides visibility for debugging, enabling the reliable production deployment of generative AI agents. The post illustrates this with an open-source video generation system that uses Gemini 2.5 Flash to script scenes and Veo 2 to generate video clips, demonstrating Temporal's role in orchestrating these multi-step, potentially hour-long processes. Key technical contributions include showcasing Temporal's durable execution for stateful, long-running processes, its built-in retry policies for transient failures, and its event history for debugging. The code examples demonstrate using Pydantic for structured output from Gemini and how Temporal handles parallel execution of video generation activities.
  28. Durable Execution meets AI: Why Temporal is ideal for AI agents & Generative AI AppsThis post details how Temporal's Durable Execution is ideal for AI agents and Generative AI applications. It maps core AI application elements (chains, graphs, agentic loops, LLMs, tools, memory, checkpointing, human-in-the-loop, long-running processes) to Temporal's features (Workflows, Activities, Signals, Updates, Queries, Workers). It emphasizes that Temporal Workflows orchestrate AI application logic and Temporal Activities provide resilient interfaces to LLMs and tools, handling retries and other failure scenarios implicitly. The post also discusses the use of Temporal Activities for invoking MCP servers and accessing data sources.
  29. Durable MCP: Using Temporal to give agentic systems superpowersThis post introduces the concept of 'Durable MCP' by demonstrating how to implement Model Context Protocol (MCP) tools as Temporal Workflows. This approach leverages Temporal's Durable Execution framework to provide reliability, scalability, and fault-tolerance to agentic systems that utilize MCP. The example shows a Python tool that starts a Temporal Workflow to fetch weather data, ensuring the operation is durable and retriable. This enables agentic systems to have robust, enterprise-grade tool execution capabilities.
  30. Building an agentic system that’s actually production-readyThis post defines agentic systems and their core components (AI, Goal, Tool, User, Agent, Agentic, Agentic System) and outlines the agentic flow (Interaction, Decision, Action). It highlights the challenges of productionizing agentic AI, such as non-determinism, complexity, debugging, security, and scaling, arguing that agentic systems are inherently complex distributed systems that require durable orchestration. Temporal's Durable Execution is presented as a solution to these challenges. A simplified agentic workflow framework using Temporal's Signals and Activities is provided as a code example.
  31. From AI hype to durable reality — why agentic flows need distributed-systems disciplineThis post argues that AI systems, when scaled beyond a single machine or prepared for production, become distributed systems problems. It highlights how Temporal addresses these challenges by providing out-of-the-box workflow engine capabilities for state management, retries, timeouts, back-pressure, and event replay, along with built-in tracing and metrics for observability. It specifically details how Temporal's Durable Execution, Polyglot Freedom (supporting multiple languages like Python, Java, Go, TypeScript, .NET, Ruby, PHP), Nexus for unified observability across AI and non-AI paths, and the use of Signals, Queries, and MCP transform fragile conversational loops into crash-proof, replayable workflows. The post also discusses developer velocity improvements due to reduced boilerplate and the inherent scalability of implementing AI tools as Temporal Workflows.
  32. Making friends with agents: A mental model for Agentic AI applicationsThis post introduces a mental model for understanding agentic AI applications, focusing on the core components: prompts, tools, event loops, and durable invocation. It details how LLMs are used to drive application flow by selecting and executing tools, and how the agent developer is responsible for building the prompt, tool library, and mechanisms for turning LLM decisions into tool execution and updating LLM input. The post emphasizes the need for a durable event loop and durable invocation of LLMs and tools to handle failures and ensure reliable execution. It also discusses the language of LLMs and tools, including the use of Model Context Protocol (MCP) for tool specifications and the preparation of data for tool invocation. The LLM input is described as containing the goal, tools, example conversation, context instructions, and conversation history.
  33. How Dust Builds Agentic AI with Temporal WorkflowsThis post details how Dust uses Temporal Workflows as the orchestration engine for their agent platform, integrating with enterprise tools like Slack, Notion, and GitHub. It highlights the use of Temporal for real-time data ingestion, enrichment, and indexing, managing complex, long-running AI tasks as Temporal Activities. The post emphasizes Temporal's role in providing persistence, retry logic, and state recovery for these workflows, enabling Dust to focus on product development rather than custom orchestration infrastructure. It also showcases a code snippet for filtering files during repository extraction within a Temporal Activity, demonstrating Temporal's ability to handle stateful, retry-enabled, and observable orchestration.
  34. Improving our Java SDK with Codex by OpenAIThis post details the use of OpenAI's Codex to assist in the development of Temporal's Java SDK. Codex was used to find and fix bugs, implement missing features (like counting workflow executions using search attributes), and perform refactoring. The post highlights the process of providing GitHub issues and requirements to Codex, iterating on its contributions, and the introduction of AGENTS.md files to guide AI agents in understanding codebases. Several PRs demonstrating Codex's contributions to the Java SDK, Temporal core, and SDK core are linked.
  35. What are Agentic AI Workflows? Scalable & Durable WorkflowsThis post introduces the concept of Agentic AI workflows as a scalable and durable alternative to short-lived chains of tools, highlighting Temporal's role as a robust foundation. It details how Temporal's features like scheduled execution, retry capabilities, and long-running state management address the limitations of current agentic AI frameworks. The post outlines a typical Temporal agent orchestrator workflow involving user requests, agent activities, LLM queries, tool execution, and user confirmation, emphasizing Temporal's ability to handle complex, stateful, and long-running AI interactions with human-in-the-loop support and flexible integration options.
  36. Multi-agent Workflow patterns and modern use cases | TemporalThis post details how Temporal's Durable Execution enables dynamic AI agents to rely on robust orchestration for multi-agent workflows, including conversational AI, data pipelines, and recommendation engines. It highlights Temporal's role as a general-purpose backbone for agentic systems, providing a service mesh and stateful coordination for agents, enabling reliable async communication, parallel processing, and long-running workflows. A practical example of a multi-agent customer support system is provided, demonstrating Temporal's ability to orchestrate agents for request classification, data lookup, and routing.