A background job or a multi-step AI agent loop has to survive things a normal function call never has to: a worker restarting mid-step, a third-party API timing out on the third retry, a deploy landing while thousands of runs are mid-flight. Handling that by hand means rebuilding a state machine and a retry policy for every pipeline you write. I went deep on this, including a real cost comparison across three vendors, in a longer piece on DevToolLab - here's the short version.
The trigger for writing it: on September 14, 2026, Temporal announced a $550 million Series E at a $12.55 billion valuation, and named demand from teams building agentic AI as the reason. That tracks. An agent that calls three tools and waits on a human approval is exactly the long-running, crash-prone process durable execution engines exist for.
Who's Actually Funding This Category
Durable execution lets you write a workflow as ordinary code and have the runtime persist every step's result, so a process resumes exactly where it left off after a crash or a multi-day wait, with none of that bookkeeping written by hand. Three funded vendors are betting on this right now.
Temporal is the established name, descended from Uber's internal Cadence project. Its raise came with real usage behind it: Temporal Cloud processed over 1.9 trillion billable actions in August 2026 alone, up more than 350 percent year over year, against 4,300-plus paying customers. Inngest and Trigger.dev are the newer, TypeScript-first challengers. Inngest raised a $21 million Series A in September 2025 led by Altimeter, and Trigger.dev raised a $16 million Series A in December 2025 led by Standard Capital. Both are betting most teams shipping AI features want a lighter version of the same guarantee, without Temporal's operational weight.
What One Job Actually Costs
Here's the part a vendor comparison page won't show you: the same exact workload prices out very differently depending on what each platform actually bills.
Take 500,000 runs a month, each with four durable steps (plan, call a tool, verify, respond), each step doing about three seconds of real work. Every vendor publishes a rate card, so this is computable, not guessed:
const RUNS = 500_000
const STEPS_PER_RUN = 4
const SECONDS_PER_STEP = 3
// Temporal bills "actions": a Start Workflow plus one Schedule Activity per
// step. Completions are not billed. Rate: $50/million actions + 10% support.
const temporalActions = RUNS * (1 + STEPS_PER_RUN)
const temporalCost = (temporalActions / 1_000_000) * 50 * 1.10
// Inngest bills per whole run ("execution"), not per step. Flat $99/mo
// covers up to 1M executions.
const inngestCost = RUNS <= 1_000_000 ? 99 : null
// Trigger.dev bills a per-run fee PLUS wall-clock compute seconds.
const triggerInvocation = RUNS * 0.000025
const triggerCompute = RUNS * STEPS_PER_RUN * SECONDS_PER_STEP * 0.0000338
const triggerTotal = triggerInvocation + triggerCompute
console.log("Temporal:", temporalCost.toFixed(2))
console.log("Inngest:", inngestCost.toFixed(2))
console.log("Trigger.dev:", triggerTotal.toFixed(2))
Run against each vendor's real published rates: Temporal comes out to $137.50/month, Inngest to a flat $99/month, and Trigger.dev to $215.30/month. Inngest wins this specific shape of workload because it bills per run regardless of step count. Temporal scales with how many steps a run has, since each one is a separately billed action. Trigger.dev is the only one of the three that bills wall-clock compute time by the second on top of a per-run fee, so a slower step (a bigger file, a slow upstream call) raises its bill in a way it never does on the other two. I walk through why each number lands where it does, plus a fourth open-source option, in the full writeup.
The Four Options, Briefly
Temporal is MIT licensed and self-hostable, with the deepest production track record of the four: Netflix cut transient deployment failures from 4 percent to roughly 0.0001 percent running its CI/CD system on it, and Coinbase runs every crypto transaction through it. The tradeoff is operational weight, the open-source server needs its own persistence and visibility stores to run in production.
Inngest wraps ordinary TypeScript or Python functions in a step.run() call and handles retries and resumption for you, with the fastest local dev loop of the three. Its license is the Server Side Public License, converting to Apache 2.0 per release after three years, not a standard open license from day one.
Trigger.dev is Apache 2.0 licensed and, as of its September 2026 v4.6 release, ships agent-specific primitives (a managed streamText helper, a chat.agent transcript store) aimed squarely at AI agent loops. Its per-second compute billing is also exactly why it came out most expensive in the pricing test above.
Hatchet is the fully open-source pick: MIT licensed, Postgres-backed, no SSPL-style catch anywhere. It is younger than the other three (still on 0.x releases) with a smaller track record, but if your infrastructure cannot leave Postgres, it is the one dependency you already have.
Picking One
Count the steps in a typical run before comparing sticker prices, since that number decides which platform is actually cheapest for you: Temporal and Trigger.dev both scale cost with work done inside a run, Inngest does not until you cross a million runs a month. After that, it comes down to who is already running Go or Java (Temporal), who wants the least new infrastructure in a TypeScript stack (Inngest), who is building an AI agent product specifically (Trigger.dev), and who cannot let data leave their own Postgres instance (Hatchet).
Conclusion
This category moved fast in the last year. Temporal's raise, on the back of 1.9 trillion actions processed in a single month, is a strong signal that durable execution went from an Uber-and-Netflix niche to mainstream AI infrastructure. The real lesson from pricing one workload three ways: ask how many steps a typical run has and how long each one takes before picking a vendor. That number predicts your bill far better than any feature comparison.
References
- Original article on DevToolLab
- Cron Next Run Calculator - work out when a scheduled workflow next fires before committing a cron expression to any of these platforms.
- Webhook Signature Verifier - check the HMAC signature on an inbound event before it's allowed to start a durable run.
- Temporal Series E announcement
Top comments (0)