Inngest vs Trigger.dev vs Hatchet vs Temporal: AI Agent Job Orchestration in 2026

Picking a workflow engine for AI agents in 2026 is not the same problem as picking one for traditional background jobs. Agent runs are long, expensive, frequently stuck behind LLM rate limits, and routinely need to resume from a half-finished tool call hours later. I ran into this firsthand while wiring up the daily generation pipelines that power our 7 aggregator sites — CyberShieldTips, HoroAura, AICraftGuide, CloudHostReview, HireVane, QuickExam, and one more in stealth — plus the inference queues behind our 6 AI products (SmartExam, DiabeCheck, BizChat, DocSumm, ServiceBot, ContentForge). A single article-generation run on this site involves 9 Claude API calls, 2 image downloads, a sitemap regeneration, an IndexNow ping, and a WhatsApp notification. If any step dies — and on Hostinger shared infrastructure, something dies at least twice a week — the whole pipeline needs to recover without manually replaying the LLM token spend.

That is the brief I gave to four orchestration platforms over the past six months: Inngest, Trigger.dev v3, Hatchet, and Temporal. They all promise "durable execution" for AI workflows, but the implementations diverge in ways that matter for cost, debugging, and how much YAML you eat. Below is a real comparison written from the perspective of someone shipping production agent code, not a marketing roundup.

Why background jobs broke for AI agents

The legacy queue stack — BullMQ, Celery, Sidekiq, basic Cloud Tasks — was designed around jobs that finish in seconds or minutes and that you can safely retry from scratch. AI agent runs break three of those assumptions at once:

• Duration: A multi-step research agent that does 12 web searches, 4 summarizations, and a writeup can run 8–15 minutes. Document parsing pipelines I built on top of LlamaParse routinely hit 22 minutes per 200-page PDF.
• Cost asymmetry: Retrying a Claude 4.7 Sonnet call that already burned 80K input tokens costs real money. I measured roughly $0.24 per failed retry on our DocSumm pipeline before I added step-level checkpointing.
• External rate limits: OpenAI 429s, Anthropic 529s overloads, third-party scraping APIs all need exponential backoff that survives crashes. A queue that loses its retry state on restart will hammer the upstream API and get you throttled or banned.

Durable execution platforms solve this by recording every step's output to a log, so when something crashes mid-run, the workflow resumes at the last successful step instead of restarting. Conceptually they all do the same thing. The differences are in language ergonomics, where state lives, and what you pay.

Inngest: TypeScript-first, event-driven, fastest DX

Inngest is the platform I reach for first when a project is greenfield and the team is TypeScript-heavy. The mental model is event-driven: you send events, you define functions that listen to events, and the SDK takes care of step-level memoization. I migrated the ContentForge image-generation pipeline to Inngest in late 2025 and the rewrite was about 40% fewer lines than my previous BullMQ + custom retry-state-machine implementation.

What I actually liked in production:

• step.run wrapping is non-invasive. You wrap each side-effectful call (LLM call, S3 upload, DB write) in await step.run("name", async () => {...}). Inngest hashes the output and stores it. On replay, it skips replays of already-completed steps.
• The DAG visualizer is the best in this category. When the daily aicraftguide.com generation routine fails at step 7 of 11, I can click into the run, see the input/output of each prior step, and rerun from a chosen point. Trigger.dev has caught up here in v3, but Inngest still wins on UX.
• Native AgentKit (released mid-2025) is purpose-built for agents. It handles network-of-agents routing, shared state, and tool calls without forcing you onto LangGraph or CrewAI semantics.

Pricing as of May 2026 (always verify on inngest.com):

• Free: 50K steps/month, 7-day retention
• Hobby: ~$20/month for 250K steps
• Team: ~$500/month for 5M steps, 90-day retention, multiple environments

Note that step counts can balloon fast in AI workflows because every retry and every step.run wrapper is billed. Our ContentForge ImageGen pipeline averages 14 steps per article. At 1 article/day across 7 sites that is ~3K steps/month — well within free tier — but a tool with 50+ steps per run would push you toward Hobby quickly.

Where I would not pick Inngest: if your team is Python-primary and you do not want to maintain a TypeScript proxy service. The Python SDK exists and is improving, but the TypeScript story is clearly the first-class citizen.

Trigger.dev v3: long-running tasks, machine-tier pricing

Trigger.dev v3 — which is a complete rewrite of v2, do not confuse them — is the platform I use specifically when a task needs to run for more than 5 minutes uninterrupted on a single attempt. The v3 architecture introduced "tasks" that can run up to 1 hour by default and up to 24 hours with a higher-tier machine. That is a hard differentiator versus Inngest, where individual steps must complete in shorter timeouts (the runtime kills long-running step bodies, even though the workflow itself can span days).

I migrated the DocSumm batch PDF pipeline to Trigger.dev specifically for this reason. A large legal document pipeline that we hand-process for one of our clients regularly runs 45–80 minutes per file. On Inngest you would have to chunk that into manually orchestrated sub-steps. On Trigger.dev you let one task run for an hour, mark it durable, and walk away.

What stood out:

• Machine-tier model is honest about cost. You pick small/medium/large/xlarge machines (256MB to 8GB RAM) and the platform bills you for compute-seconds. This is closer to how AWS Lambda thinks. Inngest hides this; Trigger surfaces it.
• Concurrent-run controls per project, per task, and per "concurrency key". I use a concurrency key per OpenAI account so that one client's batch run cannot starve another client's interactive requests of API budget.
• Self-hosting is officially supported. The CLI and the runtime are open source; you can run the orchestrator and workers on your own infra. I run this on a $9/month Hostinger VPS for the lowest-traffic two aggregator sites to avoid the cloud bill entirely.

Pricing as of May 2026 (verify on trigger.dev):

• Free: 10K runs/month, 25 concurrent runs
• Hobby: ~$20/month for 50K runs, 50 concurrent
• Pro: ~$50/month for 100K runs, 100 concurrent
• Cloud Enterprise: custom pricing for SOC 2 deployments

Where I would not pick Trigger.dev: if you want event-driven pub/sub style workflows where one event fans out to dozens of listeners. Trigger's model is task-centric. You can simulate fanout but Inngest does it more naturally.

Hatchet: Postgres-backed, control freaks welcome

Hatchet is the option I push when the project lead wants their state in their own database. The architecture is interesting: Hatchet uses Postgres as its workflow state store. That means every workflow run, every step output, every retry attempt is queryable SQL. For someone like me who logs into MySQL/Postgres at least eight times a day to debug something, this is a massive productivity unlock.

The trade-off is that Hatchet's cloud is younger than Inngest's or Temporal's, and the DX is less polished. The DAG visualizer is functional but not beautiful. The SDK docs assume more from you than Inngest's. But once you accept that you are wiring something a bit more raw, the control is excellent.

Production observations:

• Postgres as state store means you can join workflow state with your business data. I built a dashboard for the QuickExam content pipeline that joins workflow_runs (Hatchet) with articles (our app) to show which articles are in which generation stage. That kind of query is awkward on the other three platforms.
• Self-hosting is the default expectation. The cloud offering exists, but a significant chunk of users run their own Postgres + Hatchet engine. Total monthly cost on a $20 DigitalOcean droplet is effectively zero beyond the box.
• Rate-limit primitives are first-class. Static and dynamic rate limits per workflow, per step, or per arbitrary key. I use this to enforce a 3 requests/second cap on a scraping target without writing custom logic.

Pricing (cloud, as of May 2026):

• Free Cloud: 1K runs/month, 30-day retention
• Growth: ~$99/month for 100K runs
• Self-hosted: free; you pay your hosting bill

Where I would not pick Hatchet: if your team has zero appetite for self-hosting and you want a polished managed cloud out of the box. Inngest and Trigger.dev have better-funded SaaS experiences right now.

Temporal: the enterprise battleship

Temporal is the platform I recommend for anyone running mission-critical workflows that absolutely must not drop runs — financial settlements, e-commerce checkouts, regulated industry pipelines. It is the most mature platform in this comparison by a wide margin, with a heritage going back to Uber Cadence, and is the only one in this list I would trust with a workflow whose failure would cost more than $10K.

That maturity comes with weight. Temporal has its own concepts — activities, workflows, signals, queries, child workflows, side effects — and you really do need to learn them. I built a small evaluation harness with Temporal in early 2026 to model whether it could replace Inngest on the BizChat conversation summarization pipeline. The answer was that it could, technically, but the team learning curve was 2–3 weeks for engineers new to durable execution, versus 2–3 days for Inngest.

What Temporal does better than anyone:

• Versioning of in-flight workflows. If you deploy v2 of a workflow while v1 instances are still running, Temporal can keep both alive without breaking the older ones. None of the other three handle this as cleanly.
• Multi-language polyglot. Go, Java, Python, TypeScript, PHP, .NET — all first-class. If your stack is mixed Go services and Python ML workers, Temporal is the only platform here that lets both call into the same workflow seamlessly.
• Battle-tested at massive scale. Companies like Stripe, Snap, Datadog, and Coinbase use Temporal for production. It is not going away.

Pricing (Temporal Cloud, as of May 2026):

• Self-hosted: free Apache 2.0
• Cloud minimum: roughly $200/month entry, then per-action billing (~$0.42 per million actions)
• Enterprise: custom

Where I would not pick Temporal: for small or solo developers building AI agent prototypes. The setup cost — both cognitive and infrastructural — is overkill until you are running thousands of workflows per day across multiple language runtimes.

Side-by-side comparison

Decision matrix: which one for which use case

I will skip the wishy-washy "depends on your needs" advice and give you concrete recommendations based on what I have actually shipped:

• Solo developer or small team, TypeScript, building AI agents: Inngest. The DX and AgentKit are unmatched at this scale. The free tier covers a lot.
• You need a single task to run continuously for 30+ minutes: Trigger.dev v3. The 1-hour-default task duration is unique.
• You want every workflow state queryable in your own Postgres: Hatchet. Self-hosted is essentially free and the SQL access pays off the first time something breaks at 2 AM.
• You are at a fintech, healthtech, or regulated industry and a dropped workflow means lawsuits: Temporal. Period. No compromise.
• Python-primary stack: Hatchet or Temporal. Inngest's Python SDK is fine but feels secondary; Trigger.dev is TypeScript-only.
• You hate vendor lock-in: Hatchet or self-hosted Temporal.

Real cost example: 7 aggregator sites generating 1 article/day each

Here is the math I ran for our specific use case. Each of the 7 aggregator sites runs a 14-step generation routine once per day. That is 14 × 7 × 30 = 2940 steps/month. Across all four platforms:

• Inngest: Free tier (under 50K). Cost: $0/month.
• Trigger.dev: 210 runs/month (1 run = full task). Free tier. Cost: $0/month.
• Hatchet Cloud: 210 runs/month, under 1K free tier. Cost: $0/month. Or self-hosted on existing VPS, $0 marginal.
• Temporal Cloud: Minimum ~$200/month entry. Cost: $200/month for this volume.

At our scale, Temporal Cloud is 10x overkill financially. I am running production on Inngest for two of the sites and Trigger.dev for the rest, with a Hatchet self-host on a $9 VPS for experimental pipelines I want to keep cheap.

What I would build today if starting from scratch

If I were greenfielding the entire 7-site content stack again in May 2026, I would put everything on Inngest. The AgentKit + step durability + DAG UI combination is the fastest path from idea to production for AI agent workflows in the small-to-medium scale. The moment a specific task in that stack needs to run more than 5 minutes uninterrupted, I would peel that one task off into a Trigger.dev v3 task and call it from Inngest. That hybrid keeps the orchestration and event-driven nature in one place and uses Trigger only for the long-runner.

If we ever grow into needing actual SOC 2 compliance for a regulated client — which is on the roadmap for late 2026 — we will reevaluate Temporal at that point. Premature adoption of Temporal for a 7-site personal portfolio would be classic over-engineering.

FAQ

Can I run Claude Code or LangChain workflows on these platforms? Yes, all four work with any HTTP-callable LLM. LangChain has first-party callbacks for tracing; you wire each LangChain call inside a step.run (Inngest), task.run (Trigger), step (Hatchet), or activity (Temporal). The orchestration layer is agnostic to which LLM library you use above it.

Do any of these handle LLM streaming responses? Streaming-back-to-user is an HTTP concern, not an orchestration concern. You stream from the worker via WebSocket or SSE to your client. The orchestrator only sees the final completed step output. All four are fine here.

Which one has the best Anthropic Claude integration? None of them have first-party "Anthropic adapters." They all let you call the Anthropic SDK inside a step. Inngest's AgentKit happens to ship examples using Claude as the default model, which is the closest thing to opinionated Claude support.

Are there other contenders worth knowing about? Mastra, Restate, DBOS, and Windmill are all in this space. Mastra is TypeScript AI-agent-specific and aimed at full-stack TS shops; I evaluated it briefly and prefer Inngest's maturity. Restate (Rust core) is interesting for ultra-low-latency workflows but smaller community. DBOS is novel — it stores all workflow state in Postgres and is closest to Hatchet philosophically. Worth watching.

What about plain BullMQ or Celery? They work and are dirt cheap, but you will end up rebuilding durable execution, step memoization, and retry checkpoints yourself. I did this once on BullMQ for the original ContentForge pipeline and lost about three weekends to it before migrating to Inngest. Save yourself the pain.

Final take

For AI agent orchestration in 2026, Inngest wins on developer experience, Trigger.dev wins on long-running task durability, Hatchet wins on cost-conscious self-hosting with queryable state, and Temporal wins on enterprise-grade reliability and language coverage. None of them is "the best" in absolute terms — they are tuned for different shapes of workload. Match the platform to the workload, not the marketing.

If you only walk away with one thing: do not roll your own durable execution layer on top of a basic queue. The cost in engineering time and missed retries will exceed any subscription fee by a wide margin within the first quarter. I learned that lesson on my own dime so you would not have to.