Hatchet
Also known as: Hatchet Cloud
Open source, MIT-licensed task queue and durable workflow engine on Postgres for AI agents and background tasks, with DAGs, durable waits, broad triggers and observability, self-hosted or on Hatchet Cloud.
Hatchet is an open source, MIT licensed distributed task queue and workflow engine built on Postgres. Tasks written in Python, TypeScript, Go or Ruby compose into DAG workflows and durable tasks with child spawning, retries, timeouts, cancellation, durable sleeps and event waits, concurrency control, rate limits, priority and batch tasks, and every task, DAG, event and agent invocation is stored in a durable event log.
Runs start from cron schedules, scheduled runs, events and webhooks from GitHub, Stripe, Slack or any sender. The dashboard shows run history with logs and alerting, OpenTelemetry exports traces, and Prometheus exposes worker metrics. A CLI bundles an MCP server so coding agents can trigger and inspect runs, and cookbooks show agents built on the Claude Agent SDK and OpenAI Agents SDK running as Hatchet tasks.
Hatchet self hosts with Docker Compose or Kubernetes, or runs on Hatchet Cloud, with a free Developer plan covering the first 100,000 task runs and $10 per million after, Team at $500 a month, Scale at $1,000 a month with audit logs and HIPAA, and custom Enterprise with SSO and bring your own cloud. SOC 2 Type II applies from the free plan up.
Vendor details
Canonical URL
https://hatchet.run
Category
Agent infrastructure
Funding status
Private, pre-seed (a February 2024 round, per third-party funding data). Founded by Alexander Belanger and Gabe Ruttner, Y Combinator Winter 2024, backed by Y Combinator and Liquid 2 Ventures. Based in San Francisco.
Company status
independent
Use cases & customers
Primary use cases
Target customers
Deployment options
Integrations
Provides SDKs for Python, TypeScript, Go, and Ruby, webhook-based triggering from upstream data sources, OpenTelemetry-based observability, and runs on PostgreSQL as its only required dependency; workers run on the user's own infrastructure.
In practice
Your support agent, built with the OpenAI Agents SDK, keeps failing halfway through long tool chains. You run each step as a durable Hatchet task, so after a crash it replays the completed steps and carries on instead of starting over.
A refund over a set amount needs a manager's sign off before it goes out. Your workflow suspends on a durable event wait until the approval event arrives or a timeout passes, then continues or stops.
Every new Stripe payment should start document generation and a welcome email. A Hatchet webhook endpoint starts the workflow, and the dashboard shows each task's logs so you can replay a run that went wrong.
Sources & related URLs
Related / legacy domains
Agentic Index coverage score
8.5 / 14 capabilities · 61%
| Integrations & Tool Calling | Partial |
|---|---|
|
The customer's agents and tools run here, but Hatchet does not supply them. Cookbooks show agents built with the Claude Agent SDK and the OpenAI Agents SDK running as Hatchet tasks, and any task can call an outside API. There is no connector catalog, custom tool route or framework for authenticated actions of Hatchet's own, so the tools and credentials are the customer's code. Webhook integrations with GitHub, Stripe and Slack start runs. Sourcedocs.hatchet.run/cookbooks/hatchet-claude-agent-sdk-trusted-envread 2026-09-23 |
|
| Workflow Orchestration | Full |
|
Tasks compose into DAG workflows and durable tasks that can spawn child tasks, so Hatchet works as a workflow engine. They carry retry policies, timeouts, cancellation, durable sleeps and event waits, along with concurrency control, rate limits, priority, batch tasks and bulk triggering. Workers run them in Python, TypeScript, Go and Ruby. Sourcedocs.hatchet.run/v1/directed-acyclic-graphsread 2026-09-23 |
|
| Knowledge Grounding & RAG | Not documented |
|
There is no retrieval structure that Hatchet maintains over the customer's corpus. Its cookbooks run document pipelines as tasks, but the parsing, indexing and retrieval are the customer's own code. Sourcedocs.hatchet.run/cookbooks/pdf-pipelineread 2026-09-23 |
|
| Human Oversight & Guardrails | Partial |
|
Holding for a person runs on durable waits that the customer's code calls. A durable event wait suspends a task until a matching user event arrives, filtered with CEL expressions, or until a timeout passes, and workflows can be paused and resumed. This is a general wait put to use for approval. There is no approval step, approver identity, review screen or policy guardrail of Hatchet's own. Sourcedocs.hatchet.run/v1/durable-event-waitsread 2026-09-23 |
|
| Security, Identity & Governance | Full |
|
SOC 2 Type II applies from the free Developer plan, and HIPAA with audit logs from the Scale plan. Tenants separate environments, each with its own users. Hatchet Cloud signs users in with Google or GitHub OAuth, enterprises can set up custom SSO, and Enterprise includes SSO and audit logging. Sourcehatchet.run/pricingread 2026-09-23 |
|
| Observability & Auditability | Full |
|
Every task, DAG, event and agent invocation is recorded in a durable event log shown in the dashboard, with real time monitoring, alerting and task logs. Traces export through OpenTelemetry, Prometheus metrics are exposed, audit logs are kept from the Scale plan, and data retention is set by plan, at 3 days on Team and 7 on Scale. Sourcedocs.hatchet.run/v1/opentelemetryread 2026-09-23 |
|
| Memory & State Persistence | Partial |
|
State lasts within one run. Hatchet is durable by default and stores every task, DAG, event and agent invocation in a durable event log, so a durable task replays its completed steps and carries on after a failure. But the checkpointed state only lets the same run finish and carries nothing into the next run. Sticky worker assignment keeps local memory on one worker for a workflow's tasks, which is placement, not a store. There is no state store that persists across runs, keyed per user, conversation or entity, for agent memory. Sourcedocs.hatchet.run/v1/durable-executionread 2026-09-23 |
|
| Deployment & Data Residency | Full |
|
Customers can self host in their own infrastructure on Docker Compose or Kubernetes under an MIT license, and there is an embedded mode. Hatchet Cloud is the managed service, and Enterprise offers custom deployment and bring your own cloud. Sourcegithub.com/hatchet-dev/hatchetread 2026-09-23 |
|
| Prebuilt Agents / Templates / Packs | Partial |
|
Starting points come as cookbooks for webhook handlers for GitHub, Stripe and Slack, document pipelines, email flows and agents built on the Claude Agent SDK and OpenAI Agents SDK, plus skills that coding agents can install. These are examples a developer builds from, not a catalog of agents a customer adopts. Sourcedocs.hatchet.run/cookbooksread 2026-09-23 |
|
| Triggers & Channel Coverage | Full |
|
Work wakes on its own through cron runs, scheduled runs, events that trigger workflows, and webhook endpoints that start runs from GitHub, Stripe, Slack or any sender, and one service can trigger work in another. Sourcedocs.hatchet.run/v1/webhooksread 2026-09-23 |
|
| Model Flexibility & Routing | Not documented |
|
There is no model in Hatchet for the customer to choose. The model lives in the customer's own agent code, and the cookbooks use the OpenAI Agents SDK and the Claude Agent SDK, while Hatchet schedules and records the tasks whatever the model is. It works with any model only because the model belongs to someone else, and it offers no model selection of its own. Sourcedocs.hatchet.run/cookbooks/hatchet-openai-agents-sdk-trusted-envread 2026-09-23 |
|
| APIs / SDKs / MCP Extensibility | Full |
|
Official SDKs for Python, TypeScript, Go and Ruby make the platform callable from outside, alongside a REST and gRPC API for triggering and inspecting runs and the hatchet CLI. A local MCP server bundled with the CLI lets coding agents trigger runs, inspect status and events, and list workers. Sourcedocs.hatchet.run/v1/using-coding-agentsread 2026-09-23 |
|
| Testing, Debugging & Optimization | Partial |
|
When a run goes wrong, it can be replayed from the durable event log, retried or canceled in bulk, and inspected by a coding agent through the MCP server. That helps with debugging, not testing. There is no evaluation harness, scored test cases or quality gate of Hatchet's own. Sourcedocs.hatchet.run/v1/durable-executionread 2026-09-23 |
|
| Browser / Computer-use | Not documented |
|
The agent operates no browser or desktop, and Hatchet has no browser automation environment of its own. It schedules and runs the customer's tasks on the customer's workers. Sourcedocs.hatchet.run/v1/using-coding-agentsread 2026-09-23 |
|
The Agentic Index coverage score grades every vendor Full, Partial or Not documented against the same 14 buyer facing capabilities, from public evidence only. Each capability links to how all vendors in the index score on it. How this evidence is graded
Recent platform changes
Pay as you go pricing replaced Hatchet Cloud's self serve plans for new signups. The first million task runs and million events each month are free, then $30 per million runs and $5 per million events, with retries not billed, and the old Team, Starter and Growth plans are being retired.
Bears on: Pricing / packaging
View sourceHatchet v0.107.0 bundles a local MCP server into its CLI, letting coding agents trigger runs, inspect run status and events, and list workers.
Bears on: MCP / tool calling / API
View sourceHatchet introduced idempotency keys to ensure workflows execute exactly once, and batch tasks to automatically aggregate multiple tasks into a single run. The release also includes hatchet-embedded for running a sidecar engine during local development, and a Slot Cost API to manage worker resource allocations.
Bears on: Memory / state
View sourcePricing
Developer free plus $10 per 1M runs · Team $500/mo plus usage
Monthly plan plus usage at $10 per million task runs; the Developer plan includes the first 100,000 runs
Cost watchouts
Every task run counts toward usage, so fan-out and retries multiply runs; data retention is short (3 days on Team, 7 on Scale), and HIPAA, audit logs and SSO sit on Scale or Enterprise.
Variable cost rationale
Usage is billed per task run on top of the plan fee, so fan-out, retries and fine-grained task splitting raise cost.
Overage / add-ons
Self-host scales with your own infrastructure; Cloud usage scales with task throughput.
Sales call required
No, self serve available
Free / trial
Developer plan free with the first 100,000 task runs, no credit card; self-hosting free under MIT
Lowest paid plan
Team $500 a month plus usage
Key ambiguities
The jump from the free Developer plan to Team at $500 a month is steep, and usage is metered per task run on every plan, so cost depends on how finely work is split into tasks.
Related vendors
- AgentOps — Agent observability and debugging platform: open source SDKs trace…
- Agno — Python agent framework and AgentOS runtime (formerly Phidata) for…
- AIsa — Resource and payment gateway for AI agents, with one key to 110+…
- AlphaBitCore — AI control plane for regulated financial firms: one gateway enforces…
- Anchor Browser — Cloud hosted browser infrastructure that lets AI agents operate real…
- Apify — Cloud platform and marketplace of more than 73,000 ready-to-run…
Alternatives to Hatchet
The closest documented capability profiles to Hatchet among agent infrastructure platforms tracked by Agentic Index, ordered by similarity on the same 14 point evidence the rankings use. No vendor pays for placement.
- DBOS8.5 / 14Matches Hatchet across all 14 documented capabilitiesHatchet vs DBOS →
- Temporal8.5 / 14Matches Hatchet across all 14 documented capabilities
- Restate8.5 / 14Fuller documented coverage on Memory & State Persistence
- Inngest10.0 / 14Adds documented Model Flexibility & Routing
- C TWO8.5 / 14Fuller documented coverage on Integrations & Tool Calling and Human Oversight & Guardrails
- Netlify10.5 / 14Adds documented Knowledge Grounding & RAG and Model Flexibility & Routing
Similarity is computed from each vendor's Agentic Index coverage score evidence, axis by axis, not from the totals. How this evidence is graded