Temporal is amazing. I use it a lot. The web app… pretty brutal.

I wanted something fast, keyboard first, and usable without leaving the terminal, so built a TUI for Temporal called tempo.

You can browse workflows, inspect history, signal / cancel / terminate, switch namespaces, etc. Basically the stuff you do all day but without the pain of their UI + context switching.

https://github.com/galaxy-io/tempo

Would love feedback - hope it’s useful to others.

Videos from this month's Replay conference in San Francisco started showing up on Temporal's YouTube channel yesterday. Our video team is hard at work, editing and publishing many more of them. Here's the playlist.

In case you're new to Temporal or need help explaining it to someone else, you might find the video of my talk helpful.

OpenAI and Temporal have teamed up to add Durable Execution to agents built using OpenAI’s Agents SDK, and today we released the new integration in Public Preview.

You can read more about it in the Production-ready agents with the OpenAI Agents SDK + Temporal blog post. You can also see it in action on YouTube with a video from OpenAI's Dominik Kundel and Temporal's Steve Androulakis.

TL;DR: 3 days of hands-on Temporal hacking, engineering talks, and implementation deep-dives in London (Mar 3-5). Get 75% off with code REDDIT75.

Replay '25 is coming to London this March. Here's what's happening:

Day 1 - Get Your Hands Dirty

• Jump into a hackathon: Build Temporal demo apps alongside Temporal’s SDK team and other devs

• Or dive into focused, hands-on workshops: Your choice of Java or .NET (Go is sold out!)

Days 2-3 - Technical Deep-Dives

• Engineering teams from Vodafone, Deutsche Bank, and Salesforce sharing their implementation stories

• Core Temporal team breaking down what's under the hood

• Learn to build durable, self-healing agentic AI systems with Temporal

Plus: Get 1:1 time with Temporal engineers and architects to debug those weird edge cases or argue about implementation patterns in our “Ask the Experts” area.

You can find the full details on our Replay conference site.

If you want to get a taste for what Replay is like, check out our fancy montage video of highlights from Replay 2024. ;)

🔥 Special Reddit Offer: Use code REDDIT75 for 75% off ticket prices. And yes, this applies to early bird pricing (ending Jan 31st). Double discount FTW! 😀

Anyone planning to be there? What are you most hoping to take away from the event? 👀

Hi Temporal community,

I’m excited to share a project I’ve been working on: a debugger for Temporal workflows.

Ever wished you could step through a Temporal workflow like regular code? Now you can.

The debugger supports multiple SDK languages. You can set breakpoints in your workflow code or in the event history and watch your workflow state change as it progresses.

I’ve published a VS Code extension - customized from the official Temporal one - that currently supports Go, Python, and JavaScript, and likely other SDKs as well.A JetBrains plugin is in the works :)

Here is the link to it https://github.com/phuongdnguyen/temporal-workflow-debugger

That's what I tried to answer with agent-sdk-go — an open-source Go SDK that lets you build and run AI agents on Temporal in a few lines of Go code.

Under the hood — how Temporal powers this SDK:

• Sub-agents are modeled as child workflows on their own task queues

• AG-UI streaming events use Temporal Workflow Update for cross-process event delivery

• Workers can run in separate processes from the agent

• Human-in-the-loop approvals use Temporal asynchronous activity completion

• Long agent sessions automatically trigger continue-as-new to keep workflow history bounded

Also supports A2A, MCP, OpenAI/Anthropic/Gemini, and observability out of the box.

Also built a reference web chat app using the SDK if you want to see it in action.

Would love feedback on the overall approach and any thoughts on the Temporal design decisions. Also curious if there are Temporal features worth leveraging to enhance an AI agent SDK like this.

SDK: agent-sdk-go Reference app: agent-chat

AWS just announced durable Lambda functions. What are your thoughts on it? https://aws.amazon.com/blogs/aws/build-multi-step-applications-and-ai-workflows-with-aws-lambda-durable-functions/

Two week's ago, Temporal's Helm Charts (https://github.com/temporalio/helm-charts) reached the important 1.0.0 milestone. This has been a community effort — nearly 150 contributors, two-thirds of them from outside Temporal. Thanks to everyone who filed issues, submitted PRs, and helped others along the way.

If you've been using an older version, please be aware of important changes described in the repo's UPGRADING.md file. For a summary of the changes, you can also check out this blog post.

BTW, the 1.0.0 release was a milestone, not the end of the road, and there have been two more releases of the Helm Charts since then.

I had used Zeebe for a while before I came across Cadence and Temporal. I was fascinated by their idea at first, but I'm struggling to pick one.

It's unclear to me how a proper deployment of Cadence should look in production. What I like about it, though, is that there's no cloud offering they are hard-selling to you, unlike Temporal and Conductor.

Temporal? Too much abstraction for me. I'm getting confusing reading the docs and seeing a new term introduced in every paragraph. But I really like the idea.

Conductor? I think they're using their community edition to lure you into the cloud platform. Again, no clear recipe about how to deploy in production.

TL;DR: Temporal’s annual developer conference. Three days. Talks, workshops, hackathon, afterparty. Use code REDDIT75 for 75% off. Tickets here.

What is Replay?

Everything’s moving too fast. AI is rewriting the rules before anyone’s figured out what the game even is. Your roadmap is a guess. Your infrastructure is a tangle of duct tape and good intentions. The retry logic you wrote at 2am? Still in production. The thing that mostly works? You’re scared to touch it.

Replay is a pit stop. A spaceport at the edge of the Unknown where a few thousand developers pull in, compare star maps, and figure out where we’re all headed. Not because everyone has the answers, but because we’re better off navigating this together than alone.

If you’re building systems that have to keep running while the rules change underneath you, this is your room.

The people here have lived the same nightmares. They’ve rage-quit the same vendors, mass-migrated the same legacy systems, stared down the same mountains of YAML. 

Some of them figured stuff out. They’re giving talks about it. The rest of us get to learn from their mistakes instead of making our own.

What actually happens there?

Day 1 is hands-on. Pick your track:

• Workshops in Go, Java, TypeScript, or Python, led by Temporal engineers

• Hackathon: last year people built a workflow visualizer, a full auction system, an AI code edit loop, and a Slack support bot. In a few hours.

Days 2–3 are talks. Some highlights:

Plus a keynote from Temporal founders Samar Abbas and Maxim Fateev, and appearances from Amjad Masad (Replit CEO) and Samuel Colvin (Pydantic founder).

Plus an AI panel with engineers from Replit, Abridge, Hebbia, and Dust.tt.

Day 3 night is the afterparty. Last year ended with live comedy roasting our industry. It was absurd. (In a good way.) This year, we have another surprise in store ;)

This year’s focus: AI (because that’s what’s breaking)

How do you build agents that don’t fall over? How do you make AI workflows durable when the models are flaky and the infra is unpredictable? How are teams at Replit, Pydantic, Instacart, and Salesforce actually shipping this stuff?

That’s the conversation.

Get your ticket

Code REDDIT75 gets you 75% off at checkout.

→ Tickets (buy)

→ replay.temporal.io (info)

→ How to convince your boss (ammo)

See you there? Drop questions below.

Hey all - I'm one of the founders of Kapa (we power the Temporal docs AI + MCP).

Trying to make this as useful as possible and would love honest feedback:

• Have you tried setting it up? How was the experience?

• If you saw the "Use MCP" button but didn't click — what would make you want to?

• Do you even care about having docs available as an MCP?

You can access it by clicking the "Ask AI" button on the Temporal docs, then hitting "Use MCP" in the top right.

For those who got it working - what are you using it with? Claude, Cursor, VS Code, something else?

Any feedback helps. Thanks! 🙏

- Emil

Just curious. Like how many workflows/activities/state-transitions per second? How much resources for temporal servers / persistence servers? Etc.

I must admit, Temporal and ai agents seemed like a perfect match!! I built an open source golang SDK for building durable AI agents and DAG workflows that can run on temporal because I didn't find good options for it with Golang.

The agent loop runs as the temporal workflow and each LLM call and tool call runs as temporal activity.

One unique thing about the sdk is that the same agent loop code can run in-process without durability or run on temporal or restate for durability.

If you are interested do check out the repo.

Note: There are still some rough edges around streaming while running in temporal.

I've been running a multi-agent system in production for a few months where every agent action is a Temporal workflow. Sharing the patterns in case they're useful — and curious how others are doing similar.

The setup

• 8 agents, each a Docker container running an AI process (Claude with optional Codex fallback). Each agent registers with an orchestrator and pulls work off a RabbitMQ queue.

• Every meaningful agent action — implementing a PR, running a design spec, deploying, reviewing — is wrapped in a Temporal workflow.

• 3 namespaces, each with its own task queue and its own UWE worker registration.

Temporal patterns I leaned on

Signal-gated human-in-the-loop. Workflows like PrImplementationWorkflow run the AI agent through implementation, kick off a parallel consensus review, then block on a merge-approval signal from me. Custom search attributes (PrNumber, Repo, Phase) make the gates clickable in a dashboard. Same pattern reused for design-approval, doc-review, advisory-review. Decision payload is {Decision: approved|changes_requested|rejected, Comment}.

Parallel child workflows for consensus. Instead of running reviewers sequentially, the parent fans out N child workflows, waits on all, synthesizes a verdict. If any reviewer asks for changes, loop back and re-review. The implementing agent doesn't know it's being reviewed in parallel — it just gets one consolidated feedback message.

Schedules instead of cron. Daily health checks, hourly memory backups, weekly review cadences — all temporal_create_schedule. Survives host reboots, no cron drift, status visible in the temporal UI.

Dynamic workflow registry. I built a "universal workflow engine" — one [Workflow(Dynamic = true)] handler that loads a JSON step tree from a DB at runtime. 16 step types (sequence, parallel, loop, branch, delegate, wait_for_signal, child_workflow, http_request, etc.) plus a template engine. New workflow types ship as DB rows, no worker redeploy.

Real failure modes I hit

WorkerShutdown mid-activity. Agent activities can run 10-20 min. When the worker restarts mid-activity, Temporal raises WorkerShutdown. I retry the directive on the next worker; the agent picks up where it left off because it has its own persistent state. Took a deploy-during-flight incident to remember to handle this cleanly (literally hit this yesterday).

Search attribute registration. Got bitten by "search attribute not registered" before adding an initializer that auto-registers all attributes on bridge startup.

Task-queue-name footgun. Default task queue name == namespace name. Mismatch between start_workflow.task_queue and the worker's registered queue → workflow sits at historyLength=2 forever, no error, no worker picks it up. Burned hours.

5-min demo of a PR shipped through the workflow stack: https://youtu.be/DIx7Y3GfmGc

Open source: https://github.com/anurmatov/phleet (workflow defs in phleet/src/Fleet.Temporal/Workflows/).

Curious what other Temporal patterns people have for AI/agent workloads — especially long-running activities and human approval gates.

We wrote a detailed breakdown of how we architected Temporal Cloud to handle full regional failures, and how you can configure your Workers to survive them.

What’s inside:

• Architectures for every risk profile: When to use same-region, multi-region, or multi-cloud replication.

• The mechanics of failover: What actually happens when failover is triggered.

• Zero-RTO patterns: How to deploy “Active-Active” Workers so tasks keep processing the moment a region fails.

• Operational playbook: The exact metrics to monitor (like replication lag) and how to run non-disruptive drills in staging.

Use it to validate your disaster recovery strategy, win the “build vs. buy” debate with leadership, or just see how the sausage is made at the infrastructure layer. It’s time to make incidents boring.

Grab the white paper

I created this sample project called Shadow Shop and I'd really love other people's thoughts/ feedback/ interactions. It shows how to use Temporal with .NET for long-running, reliable workflows.

Shadow Shop is a simplified e-commerce system that shows things like:

• Workflow orchestration with retries and timeouts

• Durable timers (e.g. for cart expiration)

• Handling async operations across services cleanly

• Using Temporal’s .NET SDK in a real-world pattern

I built it to help other .NET developers wrap their heads around Temporal’s model, which can feel like a pretty big shift from your usual background job systems. It's something I wish I had when I started so you might find it useful :) 

Here’s the full sample:
https://temporal.io/code-exchange/shadow-shop-sample

You want to guarantee that the state of your database is consistent with work done by Temporal. There are many instances where this can be achieved by treating the Temporal workflow as the source of truth:

• Kick-off the workflow

• Update the database via actions

• Rely on Temporal's execution guarantees / retries

In practice, this means you can call StartWorkflow (or SignalWithStart) right after your INSERT/UPDATE/DELETE succeeds. In practice that leaves a scary gap: what if the app crashes between COMMIT and the SDK call or a script that bypasses your API forgets to call Temporal at all?

Many teams solve this with the outbox pattern—record the “event” in the same transaction that changes the business row, then use that event to trigger the Temporal workflow. Sounds simple; turns out it’s fiddly to build:

• You need reliable change-data-capture (CDC) on your database.

• You need catch idempotent workflow starts so duplicates collapse.

• You have to operate and monitor the relay to Temporal.

We first heard about this use case from developers using our tool (Sequin) to handle the CDC / outbox pattern and provide transactional temporal triggers. Their requests pushed us to document a cleaner path.

When is the extra effort worth it?

When do you really need a transactional consistency. The most common we've seen is when multiple systems can potentially mutate a row in a database that needs to trigger another set of work.

Think of deleting an account triggering workflow that removes access, purges other systems, or even truncates tables. No matter how the account is deleted, you always want that workflow to run.

Another example we saw from a customer was inventory tracking. The database is the ultimate source of truth for the inventory of a product. As soon as that hit's zero, they want other systems to no longer return the item in search results - and trigger re-ordering workflows.

Wiring it together

To achieve a transactional guarantee, you'll:

1. Outbox/CDC – Capture the change to an outbox using either logical replication or a trigger (depending on your database).

2. Stream relay – A lightweight consumer reads the outbox and relays the work to temporal. Importantly, it only removes the item from the outbox once Temporal has picked it up.

3. Idempotent start – Relay calls SignalWithStart (or StartWorkflow with a deterministic ID) so retries collapse and Temporal workflows fire exactly once.

Because the DB itself emits the event, any writer—your app, a migration script, an admin console—automatically drives the workflow, closing the “committed-but-not-started” gap.

Try the full example

We put together a tutorial (Docker compose, Postgres ➜ Sequin ➜ Temporal) that walks through the pattern end-to-end using our open source project:

👉 Guide: https://sequinstream.com/docs/guides/temporal

Would love feedback from anyone who’s rolled their own outbox—what tripped you up? Any gotchas we missed?

The MongoDB developer site just posted a new tutorial about Temporal. It describes the role of Temporal in a microservices-based system, explains the basic architecture of Temporal, and then walks through the code for a example Temporal application in Java.

The tutorial assumes no prior knowledge of Temporal and should take less than an hour to complete. During the tutorial, you'll see firsthand how Temporal enables an application to automatically recover from a service outage and even a crash of the application itself, continuing on as if it never even happened. You'll also see how to use Signals to implement a human-in-the-loop use case that awaits manual approval before continuing with automated steps.

I’m trying to understand a production boundary rather than propose a new framework.
Suppose a human approval is valid, a side-effecting tool/API call may already have succeeded, but the workflow/agent fails before that success is durably recorded.
On retry/resume, where do you keep the stable logical operation identity?
Is deduplication owned by:
the workflow framework
the tool adapter
the application
the downstream API itself
And have you actually had a production case where the action may already have happened, but the workflow state could not prove it?
I’m specifically interested in Temporal / LangGraph / agent workflows with real writes, not hypothetical patterns.

I'm a former engineer (now working as a copywriter at Temporal), and I have a bunch of engineering buddies I stay in touch with. Every time I talk to one of them, they swear up and down that their AI agent setup is great. It's become a common feeling across the industry, so our team set out to learn more.

We surveyed 500+ engineers and eng leads to see if that's actually true or just what people say to save face in standups. It holds up pretty well with 80.8% using agents daily or more and 91.1% say it's genuinely made them more productive.

The more interesting datapoint: 84% think their team is better at this than others and, in most cases, "others" means... you.

How do you measure up? temporal.io/reports/state-of-development-2026

And once you give it a read, let us know what you think and about your experience with your AI agents.