Trigger.dev: Webhooks for your AI agents

Product Introduction

1. Definition: Trigger.dev Webhooks is a developer platform and infrastructure service that provides hosted, code-declared webhook endpoints specifically designed for building and orchestrating AI agents. It falls into the technical categories of webhook management, workflow automation, and AI agent orchestration.
2. Core Value Proposition: It exists to solve the complex infrastructure challenges of connecting AI agents to real-world events from external services (like Stripe, Slack, GitHub). Its primary value is enabling developers to build reliable, event-driven AI agents that can start, pause, and resume based on webhook events, with built-in signature verification, deduplication, and observability, eliminating the need to build and maintain custom webhook ingestion pipelines.

Main Features

1. Hosted, Code-First Webhook Endpoints: Developers declare webhook sources and their handlers directly in their Trigger.dev task code. The platform automatically provisions and manages the public HTTPS endpoints, handling the underlying HTTP server logic. This integrates with the developer's existing CI/CD and version control workflow.
2. Verified, Deduplicated, and Recorded Ingestion: Every incoming webhook request undergoes a three-step pipeline before processing. First, it is verified using provider-specific signatures (e.g., Stripe's stripe-signature, Slack's signing secret) or custom auth schemes. Second, it is deduplicated using the provider's event ID (like Stripe's event.id) to prevent duplicate agent runs from retries. Third, the payload is durably recorded to persistent storage before a 200 OK is sent to the provider, guaranteeing no event loss.
3. Agent Orchestration Primitives: The platform provides three core actions for webhooks: Start an agent (initiate a new AI agent run), Resume an agent (wake up a previously paused run waiting for an event), and Message an agent (deliver an event to an ongoing agent's context). This is powered by the platform's ability to suspend runs indefinitely with zero compute cost while waiting.
4. Native Slack & Linear SDKs: Offers specialized NPM packages (@trigger.dev/slack, @trigger.dev/linear) that handle platform-specific complexities. For Slack, this includes verifying the signing secret, answering URL verification challenges, acknowledging events instantly, and rendering agent steps/plans/approval buttons within Slack threads. For Linear, it manages verification, 5-second acknowledgements, and deduplication of retries within Linear's agent session UI.
5. Full Observability and Replayability: Provides a dashboard with complete traces for every webhook delivery (headers, body, routing result) and every subsequent agent run (including LLM calls, tool calls, tokens, and cost). Filtered or failed deliveries are logged with reasons. Any delivery can be replayed via API or MCP server, enabling debugging and agent-assisted recovery.

Problems Solved

1. Pain Point: Manually building secure, reliable webhook infrastructure is complex and error-prone. Developers must handle HTTPS endpoints, signature verification for each service, idempotency (deduplication), durable queuing, retry logic, and observability—a significant distraction from core AI agent logic.
2. Target Audience: AI/ML Engineers and Full-Stack Developers building production AI agent applications; Startup CTOs/Founders needing rapid integration of AI into customer workflows; Product Teams adding AI features to existing SaaS platforms that interact with other tools like Slack, GitHub, or Stripe.
3. Use Cases:
   • Automated Code Review: A GitHub pull_request.opened webhook triggers an AI agent to analyze the diff, leave code review comments, and re-review on new commits.
   • Automated Customer Support & Ops: A Stripe charge.refunded webhook or a Slack message @mentioning an agent triggers a workflow that looks up customer data, requests human approval via Slack buttons, and executes the refund upon approval.
   • AI-Powered Incident Response: A PagerDuty or Sentry issue webhook triggers an AI SRE agent to analyze logs, identify root causes, and draft a fix or summary.
   • Multi-Agent Workflow Orchestration: A single GitHub webhook can fan out to simultaneously trigger separate agents for code review, security scanning, PR triage, and preview deployment.

Unique Advantages

1. Strengths & Limitations (Pros & Cons):

   • Pros:
     • Developer Experience (DX): Code-first declaration and managed infrastructure drastically reduce boilerplate and operational overhead.
     • Cost-Efficiency: "Waiting is free" model means paused agents (e.g., awaiting human approval) incur no compute costs, even for days or months.
     • Reliability: The "store-then-acknowledge" architecture and built-in deduplication prevent event loss, a critical feature for financial or operational workflows.
     • Deep Integration: Native SDKs for Slack and Linear abstract away significant platform-specific complexity.
   • Cons/Trade-offs:
     • Platform Lock-in: Adopting Trigger.dev's orchestration model ties your agent logic to their platform's specific APIs and runtimes.
     • Learning Curve: Requires understanding Trigger.dev's task/run model, which is an additional abstraction layer on top of standard serverless or serverful code.
     • Potential Latency: While webhook ingestion is fast, the agent run itself is subject to Trigger.dev's cold start times for serverless functions, which may add latency versus a always-on service.

2. Key Alternatives & Differentiation:

   • VS. Building In-House: Differentiates by eliminating 6-12 months of development time on webhook security, queuing, idempotency, and observability. Trigger.dev provides a production-ready system versus a custom, potentially fragile DIY solution.
   • VS. Generic Webhook Services (e.g., Svix, Hookdeck): These services excel at receiving, verifying, and routing webhooks but stop at event delivery (e.g., to a webhook URL). Trigger.dev's deep differentiation is its tight integration with AI agent orchestration—the webhook doesn't just deliver a payload; it natively starts, resumes, or messages a stateful AI agent run with built-in tooling, LLM tracing, and human-in-the-loop steps.
   • VS. General Workflow Platforms (e.g., Zapier, Make): Differentiates through code-centric flexibility and power. While no-code platforms are user-friendly, Trigger.dev targets developers who need complex logic, integration with custom codebases, sophisticated error handling, and the ability to build complex, multi-step AI agents that no-code tools cannot express.

Frequently Asked Questions (FAQ)

1. How does Trigger.dev Webhooks handle security and verification for custom services? For services not in their pre-built list, developers can define a custom source using multiple auth schemes: HMAC signatures, shared secrets (header, bearer token, basic auth), URL secrets, or public key verification (Ed25519, ECDSA, RSA). This provides flexibility to securely integrate with any webhook-emitting service.

2. What happens if my webhook endpoint receives traffic above its rate limit? Trigger.dev enforces per-endpoint, per-environment rate limits (e.g., 100/10sec on Free plan). When exceeded, the endpoint responds with a 429 Too Many Requests status and a Retry-After header. This instructs the sending provider (like Stripe or GitHub) to retry delivery later, preserving the event rather than dropping it.

3. Can I use Trigger.dev Webhooks to build workflows without AI agents? Yes. While marketed for AI agents, the core product is a robust webhook-triggered task orchestration platform. You can build any automated workflow (backend jobs, data pipelines, notifications) that responds to webhooks. The AI agent capabilities are a powerful layer on top of this foundation.

4. Is there a cost for webhooks that are filtered out or do not trigger a run? No. The platform only charges for the compute time used by active task/agent runs. The ingestion, verification, deduplication, and storage of a webhook—even if filtered out by your rules—is free. You can still view these filtered deliveries in the dashboard for auditing purposes.

5. How does the "wait for a webhook" feature work technically, and are there time limits? Technically, a run can call waitForRequest or similar SDK functions, which serializes its state and persists it to durable storage. The run is then suspended and removed from active compute. When the matching webhook arrives, the run state is deserialized and resumes execution. A run can wait for a maximum of 90 days for a specific webhook event.