---
title: "Trigger.dev for AI agents (2026): chat.agent, realtime streams, pricing and v4 self-hosting — Cadenya"
url: "https://cadenya.com/other-content/trigger-dev-for-ai-agents"
description: "Trigger.dev for AI agents: chat.agent with AI SDK useChat, realtime streams to the frontend, Trigger.dev pricing per second and per run, v4 self-hosting requirements (Docker, Kubernetes, Postgres, Redis, ClickHouse), runs locked to a version, and atomic deploys with the Vercel integration."
---

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](#what-does-cadenya-offer-that-triggerdev-doesnt) 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](/other-content/inngest-vs-temporal-for-ai-agents) and [Restate vs Temporal](/other-content/restate-vs-temporal-for-ai-agents) 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](/other-content/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](/other-content/durable-agents-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](/docs/guides/the-basics/objectives) 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](https://cadenya.com/auth.md) explains. To create an account, sign up at [app.cadenya.com/signup](https://app.cadenya.com/signup?utm_source=cadenya.com&utm_medium=article&utm_campaign=trigger-dev-for-ai-agents), then copy your API key from the API keys page at `app.cadenya.com/account/apiKeys`.