New projects in @triggerdotdev now open with a "Copy AI agent prompt" button.
Paste it into Claude Code or Cursor and your agent goes from an empty repo to a task that's registered and verified in the dashboard.
How it works ↓
Setup a Smart column to point at a run's payload, metadata, or output with a JSON path:
$.𝚘𝚛𝚍𝚎𝚛.𝚝𝚘𝚝𝚊𝚕 as a number
$.𝚌𝚞𝚜𝚝𝚘𝚖𝚎𝚛𝙸𝚍 as text
$.𝚜𝚝𝚊𝚝𝚞𝚜 as a badge
Give it a label and it fills in down the whole list.
You can now show, hide, or reorder columns on the @triggerdotdev runs list. You can also add smart columns that pull a single value straight out of a run and display it for every row. ↓
Every environment in @triggerdotdev used to authenticate with a single secret key.
Now each environment can hold as many keys as you want. Every service, CI job, and integration gets its own scoped credential.
↓
You can run bulk cancel and replay straight from the SDK.
Point 𝚛𝚞𝚗𝚜.𝚋𝚞𝚕𝚔.𝚛𝚎𝚙𝚕𝚊𝚢() or 𝚛𝚞𝚗𝚜.𝚋𝚞𝚕𝚔.𝚌𝚊𝚗𝚌𝚎𝚕() at a filter and it hits every matching run, from a handful to millions. ↓
New in @triggerdotdev: the health report.
One command tells you if your project is actually healthy:
– is work starting?
– are runs succeeding?
– is your telemetry fresh?
𝚝𝚛𝚒𝚐𝚐𝚎𝚛 𝚛𝚎𝚙𝚘𝚛𝚝 𝚑𝚎𝚊𝚕𝚝𝚑 ↓
Define your prompts in code. Override them live when you need to.
On @triggerdotdev a prompt is an id, a model, typed variables, and a template, and every deploy creates a new version.
Override the text or model from the dashboard, no redeploy ↓
The MCP server for @triggerdotdev does a lot more than deploy and trigger tasks now.
Your coding assistant can chat with your deployed agents, manage prompt versions, and pull a health report. All from Claude Code or Cursor. ↓
You could always see what a task did. Now you can see what it spent.
Every LLM call your @triggerdotdev tasks make becomes a span in the trace. One flag, 𝚎𝚡𝚙𝚎𝚛𝚒𝚖𝚎𝚗𝚝𝚊𝚕_𝚝𝚎𝚕𝚎𝚖𝚎𝚝𝚛𝚢, on any Vercel AI SDK call. Nothing to install.
Whole AI bill, or any single call, in the trace ↓
Every turn is a span in the dashboard: the prompts, the responses, the tool calls, how long each took.
An AI metrics dashboard ships with every project too: spend, tokens, latency percentiles, cost by model. No instrumentation to write.
𝚌𝚑𝚊𝚝.𝚊𝚐𝚎𝚗𝚝 is a chat backend where every conversation runs on its own real machine.
It boots on the first message, runs as long as the work takes, and keeps its memory between turns.
Here's how one is put together, with @triggerdotdev ↓
Why we built it:
- No timeouts. 1 in 20 turns runs over 36 minutes in production
- Refresh mid-response and the stream picks up where you left off
- Waiting is free. An agent can wait overnight for a human approval
@arena runs Agent Mode on it at scale. It went GA in July and is Apache 2.0
Star any page in the @triggerdotdev dashboard and it pins to Favorites at the top of the side menu, filtered views included.
You can also rename favorites, hide the items you never open, and drag the menu into the order you want.
trigger.dev/changelog/dashbo…
🏆 Grand prize: WhereHouse by Andrei Komkov
Ask where to open your business, get a live map that builds itself. ClickHouse runs as both the database and web server, Trigger orchestrates the agent.
Demo: piped.video/watch?v=jv_b7LEW…
Code: github.com/andrewkomkov/wher…
The brief: build a chat agent that changes how people interact with information.
@triggerdotdev runs the orchestration and AI agents. ClickHouse is the real-time data layer underneath.
Applications for our hackathon close tomorrow (16 July).
Co-hosted with our friends at @ClickHouseDB.
One week to ship a production-quality AI chat agent, free cloud credits for both platforms if you get in.
With a €10,000 prize pool, hardware, cloud credits and swag.↓
Every booking on @calcom fans out into webhooks, emails, SMS, calendar APIs, Salesforce events for enterprise, billing, and fraud checks.
All of it runs on Trigger. Morgan Vernay from the Foundation team on how it works ↓
Your tasks can now connect to private resources in your AWS VPC.
RDS, ElastiCache, internal APIs, self-hosted services. No public endpoint, no IP allowlist, no VPN.
Over AWS PrivateLink ↓
The list and individual error page filter by task version. The chart stacks errors by version.
The shape of a fix landing: a tall bar that tapers off the moment `𝚟𝟷.𝟺.𝟽` ships.
Every error has a status: unresolved, resolved, or ignored.
Mark resolved when you've shipped the fix. Ignore for hours or days when you're not ready to deal with it. Bulk actions on the list let you triage many at once.
Alerts fire once per error group, not once per failed run.
(Slack timestamps use `<!𝚍𝚊𝚝𝚎^>` tokens, so London + SF in the same channel render their own time.)
Failed runs get fingerprinted by error type and message, with dynamic parts (IDs, timestamps) stripped.
200 instances of `𝚄𝚜𝚎𝚛 𝚊𝚋𝚌-𝟷𝟸𝟹 𝚗𝚘𝚝 𝚏𝚘𝚞𝚗𝚍` and `𝚄𝚜𝚎𝚛 𝚡𝚢𝚣-𝟽𝟾𝟿 𝚗𝚘𝚝 𝚏𝚘𝚞𝚗𝚍` collapse into one row with a count and a timeline.
Errors: find and fix your bugs faster.
You can now quickly track down what’s causing your runs to fail with error alerts. Then bulk replay when you’ve shipped the fix.
↓
Send from React in a few lines.
`𝚞𝚜𝚎𝙸𝚗𝚙𝚞𝚝𝚂𝚝𝚛𝚎𝚊𝚖𝚂𝚎𝚗𝚍` wires up any button, form, or chat input to a running task. Typed all the way from the click to the task.
Need a human in the loop? `.𝚠𝚊𝚒𝚝()` suspends the task entirely.
The process gets freed. Zero compute cost while it waits. Data lands, task resumes exactly where it left off.
Timeout up to 7 days.
Cancel buttons, finally the easy way.
Register a `.𝚘𝚗()` listener for a cancel stream. User clicks stop, you abort the @aisdk completion mid-stream.
No polling. No external pubsub. No race conditions.
The pattern that unlocks everything: `𝚜𝚝𝚛𝚎𝚊𝚖.𝚘𝚗(𝚑𝚊𝚗𝚍𝚕𝚎𝚛)`
Define a typed stream once. Listen for messages in the background while your task works.
Your agent is researching. Your user types "actually, focus on pricing." The task picks it up mid-run and adjusts.
ALT Code snippets define a message stream system with handlers for user instructions and a research task managing context and messages.
You can now chat with your running tasks.
Input streams: send typed data INTO a @triggerdotdev task while it's executing.
- Cancel signals for AI generations
- Course-correct agents mid-run
- Approval gates that free compute while they wait
Shipped in v4.4.2 ↓
→ Dashboards
Every project ships with a pre-built one: run volume, success rates, failures, costs, versions. Build custom ones on top with big numbers, charts, and tables. Filters apply across every widget at once.
→ Query.
Ask "what are my p95 durations for the chat task?" and the AI writes the TRQL, runs it on ClickHouse, renders the chart. Or write the SQL yourself.
→ Our @vercel integration is live.
Push code, tasks deploy automatically. Env vars sync both ways. Atomic deployments gate Vercel's promotion until your tasks are ready, so your app never goes live with a mismatched task version.
No 𝚝𝚛𝚒𝚐𝚐𝚎𝚛.𝚍𝚎𝚟 𝚍𝚎𝚙𝚕𝚘𝚢, no CI/CD workflow.
In case you missed it, here are some of the things we shipped in March:
→ Native @vercel integration
→ Query & Dashboards (ask in English, get SQL)
→ 5x throughput from a Bun rewrite
→ New MCP tools, TTL defaults, 𝚜𝚢𝚗𝚌𝚂𝚞𝚙𝚊𝚋𝚊𝚜𝚎𝙴𝚗𝚟𝚅𝚊𝚛𝚜
Full recap ↓
Three tasks, each in its own container:
𝚑𝚊𝚗𝚍𝚕𝚎-𝚙𝚛: fetches the diff, calls Claude, posts a single review comment (HTML anchor 𝚊𝚒-𝚛𝚎𝚟𝚒𝚎𝚠-𝚜𝚞𝚖𝚖𝚊𝚛𝚢 prevents duplicates on re-runs)
𝚑𝚊𝚗𝚍𝚕𝚎-𝚒𝚜𝚜𝚞𝚎: Claude classifies, parses JSON labels, applies via GitHub API
𝚑𝚊𝚗𝚍𝚕𝚎-𝚙𝚞𝚜𝚑: Claude summarizes commits, posts to Slack
GitHub sends a webhook. 60 seconds later, Claude has reviewed your PR diff, labeled your issue, and posted a deploy summary to Slack.
Built with @HookDeck + @triggerdotdev + @AnthropicAI↓
We're heading to AI Engineer Europe in London!
April 8-10 | QEII Centre, London UK | Booth G6
Come and chat with us If you're building AI agents, workflow automation, or background jobs. We'll be doing live demos, sharing what we're building, and handing out swag. See you there!
Deployments reference each other on both sides. Trigger creates deployment checks on your Vercel deployments so you can see task build status without leaving Vercel. Each Trigger deployment links back to the corresponding Vercel deployment.
No more tab-switching to figure out which app deploy matches which task deploy.
Env var sync works both directions:
Vercel → Trigger: your Vercel env vars get pulled per-environment (production, staging, preview) before each build.
Trigger → Vercel: API keys like TRIGGER_SECRET_KEY sync back automatically.
No more copy-pasting between dashboards, and you can control sync behavior per-variable from your environment variables page.
Just launched: our Vercel integration for Trigger.
Push code. @vercel deploys your app. @triggerdotdev deploys your tasks. Env vars sync both ways. Your app never goes live with mismatched task versions.
↓
You can also build your own dashboards.
Three widget types: big numbers for KPIs, charts for trends, tables for breakdowns. Drag to reorder, resize to fit, filter everything at once by time, task, queue, or scope.
You don't need to memorize the schema. There's an AI assistant built into the editor.
Describe what you want: "What are the p50, p90 and p99 durations for my process-video task?"
It writes the TRQL for you. If it fails, "Try fix error"
diagnoses and corrects it.
Behind every query is TRQL: a SQL-style language that compiles to ClickHouse.
You write familiar SELECT statements. ClickHouse executes them. Queries over millions of runs come back in milliseconds.
Right now we have two tables: `runs` for status, timing, costs, and tags. `metrics` for CPU, memory, and custom OpenTelemetry data.
Query and Dashboards are now live.
You have full SQL-powered observability over your Trigger data. You can ask:
"Why did failures spike after my last deploy?"
"What's the p95 duration for my chat task?"
"What are my most expensive runs?"
↓