Trigger.dev for AI agents (2026)

Trigger.dev for AI agents comes down to chat.agent: one durable TypeScript task per conversation, wired to the AI SDK’s useChat and streamed to the frontend with Trigger.dev realtime streams. You write the loop, deploy it as tasks, and pay per second of compute on Trigger.dev Cloud, or self-host v4 with Docker or Kubernetes on Postgres, Redis, and ClickHouse.

So pick Trigger.dev when your agent is TypeScript, your frontend already speaks useChat, and you’re happy to own the loop and its deploys. Pick Inngest, Temporal, or Restate when you want a general durable execution engine and plan to write the chat layer yourself. And if you’d rather run none of it, Cadenya is a hosted agent loop with approvals, conversation state, and model swaps built in, and nothing to host. A coding agent can set it up with no account, in a temporary workspace you claim later. What it offers is at the end.

Every price and limit below comes from each vendor’s own pages, checked on October 13, 2026.

Trigger.dev vs Inngest vs Temporal vs Restate for AI agents

These are the four products coding agents put next to each other when they searched for durable execution for AI agents in TypeScript, with Cadenya in the last column.

	Trigger.dev	Inngest	Temporal	Restate	Cadenya
What you self-host	A webapp (dashboard, Postgres, Redis) and workers (a supervisor and the runners). Production Kubernetes adds ClickHouse and object storage	One binary with every service, on SQLite by default, or Postgres and Redis	Frontend, History, Matching, and Worker services, plus Cassandra, PostgreSQL, or MySQL	One binary that persists its data to disk	Nothing. Your app calls the API and stays a stateless web tier
Server license	Apache 2.0	Server Side Public License, with delayed publication under Apache 2.0	MIT	Business Source License 1.1	None, since there’s no engine to self-host. SDKs are Apache 2.0
Free cloud tier	$0, with $5 of credits a month	$0, 50,000 executions	$150 in credits for 90 days, no base fee	A free plan	$0, 1,000 loops a month
First paid plan	Hobby at $10 a month, Pro at $50	Pro, starting at $99 a month	Pay as you go, $50 per million actions for the first 5 million	Usage based on durable actions	$49 a month for 50,000 loops, then $0.0015 a loop
What the bill counts	Compute seconds by machine size, plus $0.000025 per run	Executions	Actions and storage	Durable actions	Loops, where a loop is one LLM request

The latest Trigger.dev release is v4.7.3, published on October 6, 2026. For the engine-to-engine view, Inngest vs Temporal and Restate vs Temporal go deeper.

Trigger.dev chat.agent with AI SDK useChat, and supported languages

chat.agent runs each conversation “as a single long-lived Trigger.dev task: you write the loop, it wakes up when a message arrives, freezes when none do.” The task takes messages, calls streamText, and returns the result. This is the whole backend in Trigger.dev’s own example:

import { chat } from "@trigger.dev/sdk/ai";
import { streamText, stepCountIs } from "ai";
import { anthropic } from "@ai-sdk/anthropic";

export const myChat = chat.agent({
  id: "my-chat",
  run: async ({ messages, signal }) =>
    streamText({
      model: anthropic("claude-sonnet-4-5"),
      messages,
      abortSignal: signal,
      stopWhen: stepCountIs(15),
    }),
});

On the frontend, useTriggerChatTransport from @trigger.dev/sdk/chat/react hands a transport to useChat, and “No API routes” sit in between, with AI SDK v5, v6, or v7 on the client. You still add two server actions: one that starts the chat session and one that mints a session-scoped access token. The ownership check inside both (requireChatOwner in the docs) is your own application code.

What about a page refresh mid-answer? The transport “handles the auth refresh, reconnect, Last-Event-ID resume, and stop-signal plumbing transparently.” Pass resume: true to useChat for an existing conversation, and the stream picks up past the chunks the browser already saw.

Tool approvals use the AI SDK’s own mechanism. With AI SDK 6 or later, you set needsApproval: true on a tool, render approve and deny buttons for approval-requested parts, and call addToolApprovalResponse with the decision.

Two things stay on your side, in Trigger.dev’s words: “idempotency in your run() function, and how much state you keep in memory between turns versus persist in your own database.” And once compaction runs, the saved snapshot keeps only recent messages, so a full history means your own transcript storage.

Tasks are written in TypeScript, and if part of your agent is Python, the pythonExtension build extension runs Python scripts from inside your TypeScript tasks.

Trigger.dev realtime streams to the frontend

Outside chat.agent, Trigger.dev Realtime covers two jobs: run updates (status, metadata, tags) and streams of data you define, like AI tokens. Run updates need no task code and arrive through useRealtimeRun, while streams need SDK 4.1.0 or later and a definition in your task code:

import { streams, InferStreamType } from "@trigger.dev/sdk";

export const aiStream = streams.define<string>({
  id: "ai-output",
});

export type AIStreamPart = InferStreamType<typeof aiStream>;

Inside the task, aiStream.pipe(stream) sends an AI SDK response into it. In React, useRealtimeStream(aiStream, runId, { accessToken }) reads it back as typed parts. Current streams have “Unlimited stream length”, a 300 MiB maximum size, and “automatic resumption on connection loss.”

Realtime connections are a plan limit on Trigger.dev Cloud. Free allows 10 concurrent Realtime connections, Hobby 150, and Pro 1,000, then $10 a month per extra 1,000.

Trigger.dev v4 self-hosting: Docker, Kubernetes, Postgres, Redis, ClickHouse

Self-hosted Trigger.dev v4 is “a set of containers” in two parts: the webapp (“the dashboard and other services like Redis and Postgres”) and the worker (“the supervisor and the runners that execute your tasks”).

With Docker Compose, you need Docker 20.10.0 or later and Compose 2.20.0 or later. The webapp machine wants at least 3 vCPU and 6 GB of RAM, and the worker machine wants 4 vCPU and 8 GB, and the runs come on top: 10 concurrent runs on small-1x take another 5 vCPU and 5 GB. The compose files now ship a built-in container registry and object storage. Trigger.dev’s own warning: “This guide alone is unlikely to result in a production-ready deployment.”

On Kubernetes, the official Helm chart needs Kubernetes 1.19 or later, Helm 3.8 or later, and 6 vCPU and 12 GB of RAM across the cluster. The evaluation install bundles Postgres, Redis, ClickHouse (25.8 or newer), MinIO, and s2-lite. The production install points at “external Postgres, Redis, ClickHouse, and object storage”, and the chart expects an external container registry before you deploy tasks.

Two features stay on Trigger.dev Cloud: warm starts and auto-scaling. Self-hosted, you add worker machines by hand as your concurrency grows. And the docs advise using the version-tagged releases “exclusively and keep them locked with your CLI version.” The broader trade is in self-hosting AI agent infrastructure.

Trigger.dev pricing

Trigger.dev Cloud bills two things: compute seconds and run invocations. A small-1x machine (0.5 vCPU, 0.5 GB) costs $0.0000338 a second, and every run that starts adds $0.000025 ($0.25 per 10,000 runs). Runs in the dev environment carry no invocation charge.

Plan	Price	Included credits	Concurrent runs
Free	$0	$5 a month	20
Hobby	$10 a month	$10 a month	50
Pro	$50 a month	$50 a month	200, then $10 a month per 50
Enterprise	Custom	Custom	Custom

Trigger.dev’s own example: a 10-second task, 100 runs a day on small-1x, comes to $1.09 a month. On the Free plan, tasks stop once the $5 of credits is used, until you upgrade.

Trigger.dev versioning: runs locked to a version, atomic deploys on Vercel

“Every deployment creates a new version of all tasks.” When a run starts, it’s locked to the latest version, and “Once locked it won’t change versions, even if you deploy new versions.” A chat in progress keeps streaming through a redeploy on its old version. To move it onto new code, chat.requestUpgrade() and chat.endAndContinue() hand it to the new deployment.

The other half is version skew. Your app and your tasks deploy separately, so new app code can briefly trigger old tasks. Version skew protection (CLI and SDK v4.5.12 or later) fixes that with a shared ID:

npx trigger.dev@latest deploy --external-id "$(git rev-parse HEAD)"

Your app then sets TRIGGER_EXTERNAL_DEPLOYMENT_ID to the same commit SHA, and each run pins to the matching deployment.

The Vercel integration does both halves for you. Every Vercel deployment triggers a Trigger.dev deployment, syncs environment variables, and passes “your commit SHA as the deploy’s external id.” It needs the GitHub integration too, since Trigger.dev builds your tasks from your repository. For durable agents on Vercel without a separate task deploy, see durable agents with the Vercel AI SDK.

What does Cadenya offer that Trigger.dev doesn’t?

Trigger.dev gives you a durable place to run the agent loop you write and deploy. Cadenya is the loop: approvals, conversation state, streaming, and model swaps, with nothing to host or deploy. Here’s what that covers:

1. Nothing else to run. No webapp, worker, supervisor, Postgres, Redis, ClickHouse, object storage, or container registry. Your app calls the API and stays a stateless web tier.
2. No server to license. There’s no engine to self-host, so there’s no server license to read. The SDKs for TypeScript, Python, Ruby, and Go are Apache-2.0.
3. No versions to pin or upgrade. An objective keeps its variation’s configuration snapshot even if you edit the variation later. There’s no task bundle to deploy, no external deployment ID to match, and no upgrade call to make.
4. SDKs that ship often. All four SDKs are at 1.9.0, and the TypeScript SDK has shipped 113 versions since April 2026. A CLI and a plain HTTP API cover everything else.
5. A price in one line. Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop. A loop is one LLM request, so there are no compute seconds or machine sizes to estimate.
6. The loop, already written. Cadenya calls the model, runs the tools, and compacts the context window as a conversation grows. Every objective carries a durable event log that you can list after a run or stream over server-sent events while it works.
7. Approvals with the screen included. Mark a tool as needing approval and the objective pauses on toolApprovalRequested. Decide through the API, a webhook handler, or the React UI kit, and a denial can carry steering for the agent.
8. A chat UI with no transport to wire. Your backend mints a widget session, and the browser talks to the widget host directly. ConversationsPanel supplies the message thread, composer, tool approvals, and live event stream, and the widget quickstart ships a Next.js app to Vercel.
9. Any model, on your own keys. The model is a setting on a variation, picked from the AI providers in your workspace, so switching needs no deploy. Weighted variations use feedback to route more objectives to the configuration that scores well.

How objectives work walks through an agent turn, and the free plan needs no card.

No account yet? A coding agent can create a temporary workspace with cadenya workspaces create --temporary, run its first objectives there, and hand you a link to claim it, as auth.md explains. To create an account, sign up at app.cadenya.com/signup, then copy your API key from the API keys page at app.cadenya.com/account/apiKeys.