Trigger.dev vs Inngest: Which Should You Use in 2026?

Trigger.dev and Inngest both market a free, open-source way to run durable AI agent jobs, and both companies' own documentation quietly tells production users not to lean on it.

Trigger.dev's self-hosted deployment is Apache-2.0 licensed and free to run at unlimited scale. Inngest's self-hosting option, live since its 1.0 release, ships with a production Helm chart for Kubernetes and autoscaling via KEDA. Neither vendor's own docs actually recommend either path for a team without a dedicated platform engineer, a caveat that rarely survives into the roundups ranking for this exact search. For a founding engineer picking a background-job platform before either bill has arrived, the real decision is between two managed-cloud pricing curves, not between free and paid.

The verdict, stated plainly

Pick Trigger.dev if the stack is TypeScript-only and the team wants the cheapest possible start: its Hobby tier costs $10 a month and allows 50 concurrent runs, a step up from 20 on the $0 Free plan. Pick Inngest if agent runs need to pause mid-execution and resume several downstream workflows off one event, and the team can absorb a jump straight from a $0 Hobby plan to a $99-a-month Pro plan with no tier in between.

Neither is the wrong pick for the other's job. The two products overlap but are not substitutes, and a no-code platform like n8n answers a different question entirely for a team that does not want to write scheduling code at all. Because the right answer depends on the rest of the stack, not just these two products, HokAI's Smart Match can shortlist an option against what you are actually building before you commit to either bill.

What Trigger.dev actually costs

Trigger.dev's pricing runs in three steps: Free at $0 with $5 of monthly credit and 20 concurrent runs, Hobby at $10 a month with $10 of credit and 50 concurrent runs, and Pro at $50 a month with $50 of credit and 200 or more concurrent runs, where each extra block of 50 costs $10 more.

Individual run invocations bill separately at $0.000025 apiece, or $0.25 per 10,000 runs. Compute time is priced from $0.0000169 to $0.00068 a second depending on machine size, according to Trigger.dev's own pricing page.

Trigger.dev's pricing page, captured 2 September 2026.

What Inngest actually costs

Inngest's Hobby tier needs no credit card but caps at 50,000 executions a month, five concurrent steps, three team members and three workers. Its Pro tier starts "from $99/month" for teams that outgrow that ceiling: 1 million included executions with metered overage up to 20 million, 100 or more concurrent steps, 15 users before a $10-per-seat charge applies, and 20 workers before $10 buys ten more, per Inngest's pricing page.

There is no paid tier between Hobby and Pro. A four-person team that trips the 50,000-execution cap in week three has exactly one option, and it starts at $99 a month.

Inngest's pricing page, captured 2 September 2026. Note the jump straight from Hobby to a $99 Pro floor, with nothing in between.

· Trigger.dev · Inngest

Entry price · $0 (20 concurrent runs) · $0 (50,000 executions/month)

First paid step · $10/month (50 concurrent runs) · $99/month (1M executions)

Mid tier · $50/month (200+ concurrent runs) · none

Trace retention · not tiered by plan · 24 hours (Hobby), 7 days (Pro)

Self-hosting · Apache-2.0, unlimited, community support only · Production Helm chart, no support SLA

The gap that matters for budgeting is the missing middle. A team scaling past Trigger.dev's Hobby tier absorbs a $40 step up to Pro. A team scaling past Inngest's Hobby tier absorbs a $99 step with nothing smaller to try first, and the 24-hour trace retention on Hobby only extends to 7 days once that jump is made, not before.

Both platforms schedule recurring runs with standard cron syntax, and Trigger.dev's own tiers cap how many schedules you get (10 on Free, 100 on Hobby). A tool like Cron AI exists specifically to save someone from writing that syntax by hand: type "every Monday at 9 AM" and it returns the exact expression either dashboard expects.

What the self-hosting docs won't put in a pricing table

Most roundups covering this pairing mention that both platforms are open source. Few quote what the vendors themselves say about running that code in production. One widely cited three-way comparison covering this exact pairing, published by PkgPulse, skips pricing entirely, stating that cost "changes faster than the execution models" and focusing instead on failure semantics. That is a defensible framing for a piece about architecture, but it leaves a reader with nothing to actually budget against.

Trigger.dev's self-hosting docs state plainly: "Because we don't manage self-hosted instances, we cannot guarantee how Trigger.dev will perform on your infrastructure." Support runs through community Discord only, autoscaling and warm starts are absent from the self-hosted build, and several limits are hardcoded rather than configurable, including a 128KB cap on I/O packet length. The same docs recommend Trigger.dev Cloud instead, calling it the option with "the best experience" for most teams.

Inngest's self-hosting docs are more built out but carry an identical disclaimer: "Inngest's support team does not guarantee direct support for self-hosted instances." The default SQLite database "does not support scaling beyond a single node," so any real deployment needs external Postgres and Redis running alongside it. The docs also note that the Inngest server "does not automatically delete old database rows" for events, runs or traces, which makes table growth something an operator has to manage by hand.

Both companies built a genuine self-hosting path. Neither one is pitching it as a way to dodge the invoice.

Pausing for a human, or a tool call

An AI agent that needs a person to approve a step, or needs to wait on an external tool call, has to pause mid-run and resume later. Both platforms support this, in different shapes.

Trigger.dev's wait.forToken() function pauses one run until a token is completed elsewhere; a companion inputStream.wait() pauses until data arrives on a stream. It is built around one run waiting on one external completion.

Inngest's step.waitForEvent() pauses a function until a matching event arrives, with a timeout its docs show running as long as three days. Inngest's documentation names this pattern as useful to "implement Human in the loop in AI Agent workflows," and its event model lets one incoming event resume several waiting functions at once, each carrying its own audit trail.

Neither platform is an agent framework by itself. Teams writing the actual agent logic often pair one of these with something like Mastra, the open-source TypeScript framework for building agents and workflows, and let it call out to whichever queue underneath handles the retries.

Where Trigger.dev wins

A two-person team writing TypeScript, deploying on Vercel or Cloudflare, and wanting the lowest possible entry cost should start with Trigger.dev. Its $10 Hobby tier is a real middle step between free and a $50 commitment, a rung Inngest's own pricing table skips entirely. Unlimited task types ship on every tier, and credit-metered billing means a quiet month costs next to nothing.

A concrete case: a scheduled agent that scrapes 200 product pages nightly and retries failed fetches, with no human approval step in the loop, is exactly Trigger.dev's shape. There is nothing to pause for, so its single-run wait primitive is never a limitation, and the per-run pricing keeps a low-volume nightly job cheap.

Where Inngest wins

A team building an agent that pauses for human review, then needs that approval to unblock several waiting workflows at once, should reach for Inngest instead. Its event-driven core was built for fan-out first, and its docs market that exact pattern at AI agent human-in-the-loop use cases rather than treating it as a side effect of a generic wait call. Teams working outside TypeScript also fit here better; Trigger.dev's SDK is TypeScript-only, while Inngest ships client libraries beyond it.

A concrete case: a support agent that drafts a refund decision, waits for a human reviewer to approve it, and then has to notify billing, update the ticket, and log the outcome all at once is closer to Inngest's shape. One approval.granted event resuming three separate functions is what step.waitForEvent() is built for; recreating that fan-out on Trigger.dev means writing the coordination between three separate token waits by hand.

The case for self-hosting anyway

The obvious objection: plenty of teams do run these platforms themselves in production, and Inngest ships a genuine production Helm chart with KEDA autoscaling, not a toy docker-compose demo. That objection is fair, and it holds for a team that already operates Kubernetes, Postgres and Redis in-house.

It holds less well for the founding engineer this article is written for. "No guaranteed support" stops being a footnote the moment the job queue goes down at 2 a.m. and the only place to ask is a public Discord server. The sticker price of self-hosting is zero. The real price is whoever inherits that pager.

What switching actually costs

Moving from one platform to the other is not free once code exists against it. Trigger.dev's tasks and Inngest's step functions are written against different SDKs, so a migration means rewriting retry logic, wait calls and scheduling configuration, not swapping an API key.

A function built around step.waitForEvent() fanning one approval out to five downstream steps does not translate directly into a Trigger.dev task waiting on a single wait.forToken() call. The retry semantics and the queue depth limits differ too, so the rewrite touches error handling as well as the wait pattern.

Teams that outgrow either platform's entire execution model, not just its price, tend to look next at Temporal, the older and more complex durable-execution platform both Trigger.dev and Inngest position themselves as a simpler alternative to; that is its own migration and outside the scope of this comparison.

Neither vendor has announced a pricing change for the rest of 2026. If Inngest adds a tier below its $99 Pro floor, or Trigger.dev's Cloud pricing drops to match Inngest's free ceiling, this comparison stops holding. Until one of those happens, the platform to pick is the one whose self-hosting disclaimer you are least likely to have to test.

Frequently asked questions

Is Trigger.dev or Inngest better for AI agents?

Neither is strictly better; they fit different agent shapes. Trigger.dev suits agents that run on a schedule with no human approval step, while Inngest suits agents that pause for review and then resume several downstream workflows off one event. The right pick depends on whether your agent needs that fan-out pattern.

How much does Trigger.dev cost compared to Inngest?

Trigger.dev starts at $0 with a $10-a-month Hobby tier and a $50-a-month Pro tier, plus per-run charges. Inngest starts free too, but its paid tier jumps straight to $99 a month with 1 million included executions and no smaller paid tier in between.

Can you self-host Trigger.dev or Inngest for free in production?

Both publish open-source self-hosting code, but neither vendor recommends it for a small team without a platform engineer. Trigger.dev's docs say they cannot guarantee performance on your own infrastructure, and Inngest's docs say the same about support for self-hosted instances.

Does Inngest or Trigger.dev support human-in-the-loop AI agent workflows?

Both support pausing a run for external input. Trigger.dev's wait.forToken pauses one run until a token completes, while Inngest's step.waitForEvent pauses until a matching event arrives and can resume multiple waiting functions from a single event, a pattern Inngest's own docs recommend for human-in-the-loop agents.

What is the cheapest way to start with a durable job platform in 2026?

Trigger.dev's free tier and $10 Hobby tier are the cheaper entry point for a small TypeScript team, since Inngest's only paid step is $99 a month. Both free tiers are usable for early testing before either bill applies.

Covered in this guide

• Trigger.dev: Open-source TypeScript background job platform that eliminates serverless timeouts. Durable execution, auto-retries, real-time traces. Free tier available.
• Inngest: Inngest runs event-driven background jobs and workflows with zero infrastructure. 100,000 free executions/month on Vercel, Cloudflare, or Next.js. Pro from $75/month.
• Cron AI: Cron AI is a free open-source tool generating cron expressions from plain English descriptions for task scheduling.
• Mastra: Open-source TypeScript framework for building AI agents and workflows, routing to 90+ model providers through one interface.
• n8n: AI workflow automation platform for technical teams
• Temporal: Durable execution platform for building resilient microservice workflows used by Stripe, Netflix, Datadog, and HashiCorp at scale.

Sources