What is Hatchet?
Hatchet is an orchestration engine for background tasks, AI agents and durable workflows. Tasks are plain functions defined in code with the Hatchet SDKs for Python, TypeScript, Go and Ruby, and they run inside worker processes in the user's own infrastructure, which connect to the Hatchet engine. The engine queues and dispatches work, records every task and state transition in PostgreSQL and makes runs available for automatic retries, manual replays and debugging. The source code is in the hatchet-dev/hatchet repository and the documentation is at docs.hatchet.run.
Hatchet is developed by Hatchet Technologies, a Y Combinator W24 company whose co-founder and CEO is Alexander Belanger. On November 9, 2026 the company announced Hatchet v2 together with a $5.7M seed round. The announcement describes orchestration of sandboxes, serverless functions such as Cloudflare Workers and Vercel, and a new concept called Operators, special workers that register tasks dynamically; in v2 every DAG is run by a DAG Operator. The same text states that the core engine stays MIT-licensed and that Hatchet Cloud moved from subscription plans to pay-as-you-go pricing.
The project is distributed in several forms. The Hatchet CLI is installed with an install script on macOS, Linux and WSL, as a Homebrew cask on macOS or through npm, and hatchet server start launches a local Hatchet Lite instance in Docker. Server images are published on GitHub Container Registry (hatchet-lite, hatchet-migrate, hatchet-admin and others), a Helm chart named hatchet-stack covers Kubernetes, and an embedded mode runs the engine in-process for Go or as a sidecar for Python and TypeScript. Hatchet Cloud at cloud.hatchet.run is the managed service.
The latest GitHub release is v0.114.2, published October 26, 2026, with CLI archives for macOS (arm64, x86_64), Linux (arm64, x86_64) and Windows (x86_64) plus SBOM files. It adds pausing of rate limit keys, RetryAfter errors that choose when a task's next retry runs, FIPS 140-3 server images with a -fips suffix and workflow pause in the Go SDK. The dashboard gained a form tab built from a workflow's input schema and a "Replay as new" action, and the release lists security fixes, including a check that an API token's subject matches its tenant, and many DAG, scheduler and database fixes. SDKs are released separately; in early November 2026 these included Python SDK 1.45.1, Ruby SDK 0.12.1, a sandbox package and a serverless package.
The engine is written in Go. According to the architecture page, a deployment has an API server for the REST API and dashboard, an engine that schedules work and talks to workers over gRPC, and PostgreSQL as the source of truth; RabbitMQ is an optional message queue for high-throughput self-hosted setups. The README states that Hatchet has been load-tested to 10,000 tasks per second and uses more resources than queues built on Redis or RabbitMQ. The repository is licensed under the MIT License, and the pricing page describes Hatchet as 100% open source.
Hatchet screenshots
Explore the interface. Open a screenshot to view it at full size.
Workflow Runs view of the Hatchet dashboard, from the Hatchet documentation.
DAG workflow definition with five steps and their dependencies in the Hatchet dashboard.
Run detail for an event-triggered workflow, with input, output and step configuration.
Workflow settings with the Active and Paused status options, from the pausing workflows documentation.
Source: official Hatchet project page.
Key capabilities
- Background tasks A task wraps a single function and can be run fire-and-forget or fire-and-wait, with subscriptions to results. Every task can declare its own retries, timeouts and concurrency settings, and bulk triggering, bulk retries and cancellations are documented under the core concepts.
- Retry policies Retries are configurable per task with optional exponential backoff, as described in the retry policies documentation. Since v0.114.2 a task can return a
RetryAfterErrorto set when the next attempt runs. On Hatchet Cloud, retries are not billed as additional runs. - DAG workflows A DAG declares every task and its parent dependencies before the run. Hatchet runs independent tasks in parallel, passes parent outputs to children and persists each completed task so a retry does not re-execute succeeded parts. Parent conditions
skip_ifandcancel_ifare CEL expressions evaluated against a parent's output, as described in the DAG documentation. - Durable tasks A durable task waits for time or events and spawns child tasks, and Hatchet checkpoints progress after each wait. While it waits, the task can be evicted to free the worker slot; on resumption Hatchet replays the durable event log. The documentation requires code between checkpoints to be deterministic and side effects to be moved into child tasks.
- Durable sleep and event waits Workflows can pause on durable sleep, on events or on combinations of both, and resume when the condition is met. Workflows can also be paused and unpaused from the dashboard, and the Go SDK added workflow pause in v0.114.2.
- Concurrency strategies Concurrency limits are set on tasks or workflows with a key computed from a CEL expression over the input and additional metadata. The concurrency documentation lists Group Round Robin, Cancel In Progress, Cancel Newest, Cancel Queued Except Newest and Cancel Queued Except Oldest; a constant key gives a global limit.
- Rate limits Static rate limits are declared with
put_rate_limitbefore a worker starts, and dynamic rate limits create keys at runtime from CEL expressions, for example per user. Runs that exceed a limit are re-queued, the state of limits is shown in the dashboard, and since v0.114.2 a key can be paused so waiting tasks do not consume it. - Priority and routing Runs carry a priority of 1, 2 or 3 (low, medium, high), which orders runs of the same workflow. Tasks can be routed to workers by worker labels or by weighted worker affinity, and worker slots cap how many tasks one worker runs at a time.
- Cron jobs and scheduled runs Cron triggers accept 5-field and 6-field expressions, with seconds as the optional first field, and can be defined in the task definition, created through the SDKs or added in the dashboard. Scheduled runs start one-off tasks at a future time. The cron documentation notes that the expression sets when a run is enqueued, not when it starts.
- Events and webhooks Events pushed to Hatchet trigger workflows or satisfy wait conditions, and webhook endpoints let upstream systems trigger tasks over HTTP. The documentation includes cookbooks for GitHub, Slack and Stripe webhooks.
- SDKs for four languages The SDKs are published as
hatchet-sdkfor Python (Python 3.10 or later),@hatchet-dev/typescript-sdkon npm, a Go package in the main repository and thehatchet-sdkRuby gem. The documentation shows every code example in Python, TypeScript, Go and Ruby. - Dashboard and monitoring The web dashboard lists workflow runs with status counts and filters, shows run details with inputs, outputs and logs, displays DAG definitions and lets users trigger, replay or cancel runs. Alerting, logging, worker health checks, multi-tenancy with isolated tenants and user roles are part of the platform.
- OpenTelemetry and Prometheus Traces and spans can be sent to Hatchet's built-in collector or to external destinations through OpenTelemetry, and Prometheus metrics are available for monitoring Hatchet instances.
- Hatchet CLI The CLI is installed with
curl -fsSL https://install.hatchet.run/install.sh | bash, withbrew install hatchet-dev/hatchet/hatchet --caskon macOS or withnpm i -g @hatchet-dev/cli.hatchet server startruns Hatchet Lite locally and requires Docker, as described in the CLI setup guide. - Self-hosting with Docker Hatchet Lite is a single image with engine and API for development, testing or low-throughput production, used with PostgreSQL (the example uses
postgres:15.6) and exposing the dashboard on port 8888 and gRPC on 7077. The Docker Compose deployment adds RabbitMQ, which can be replaced by PostgreSQL as the message queue withSERVER_MSGQUEUE_KIND=postgres. - Kubernetes and operations The Helm quickstart installs the
hatchet-stackchart from hatchet-dev.github.io/hatchet-charts. Self-hosting guides cover external databases, high availability, read replicas, PgBouncer, SMTP and upgrades, and run history is kept for 30 days by default, set withSERVER_LIMITS_DEFAULT_TENANT_RETENTION_PERIOD. - Embedded mode For local tests and CI, the embedded mode starts a full engine without external dependencies, using embedded-postgres by default. Go runs the engine in-process, while Python and TypeScript download a sidecar binary that is checked against the release checksums; Ruby support is listed as coming soon.
- Labs features on Hatchet Cloud Sandboxes connect a sandbox vendor account to a tenant and run each create, exec, file and kill call as a Hatchet task with snapshots and forks; they are available on Hatchet Cloud only and enabled under Labs Preview. Durable streams and serverless endpoints are also listed as Labs Preview in the documentation.
- Hatchet Cloud pricing Pay-as-you-go starts at $0 and includes 1 million task runs and 1 million events per month, then costs $30 per million runs and $5 per million events, with durable streams at $0.10 per GB. It includes 100 workers, 10 tenants, 50 users, 7-day retention and SOC 2 Type II; without a card the limits are 2,000 runs per day and 1-day retention. A custom plan for 100M+ runs adds SSO, RBAC, audit logs, HIPAA BAA and self-hosted or BYOC options, per the pricing page.
- Cloud regions The Hatchet Cloud control plane runs in AWS us-west-2 (Oregon), and data plane regions in Oregon, N. Virginia, Ireland and Sydney are live, according to the region availability page.
Where Hatchet fits
Background job processing for web applications
An application triggers Hatchet tasks from its API, and workers pick them up with retries, timeouts and worker slot limits. Run history is persisted in PostgreSQL until the retention period ends, so failed runs can be inspected and replayed from the dashboard. Hatchet publishes a migration guide from Celery for teams moving existing task queues.
Data pipelines and ETL as DAGs
Pipelines such as document or image processing are declared as DAG workflows in which independent tasks run in parallel and outputs flow from parent to child tasks. Parent conditions skip or cancel branches at runtime. The README compares this model with DAG platforms such as Airflow, Prefect and Dagster; a related listing on iThub is Dagster.
AI agents and long-running processes
Agentic loops, human-in-the-loop approvals and runtime-selected child workflows are written as durable tasks that checkpoint after each wait and free their worker slot while waiting. Hatchet documents cookbooks for the Claude Agent SDK and the OpenAI Agents SDK, and on Hatchet Cloud, sandboxes run agent-generated code on a connected sandbox provider.
Durable execution as a Temporal alternative
The README describes Hatchet's durable tasks as a replacement for Temporal or DBOS workflows, and the documentation includes a guide from Temporal to Hatchet. The iThub listing for Temporal describes that platform's Workflow and Activity model.
Fair scheduling in multi-tenant SaaS
Concurrency keys built from input fields such as a user or organization ID limit in-flight runs per key, and Group Round Robin dispatches queued runs across keys in turn. Dynamic rate limits cap calls per user against third-party APIs, and priority values let API-triggered runs go ahead of cron-triggered runs of the same workflow.
Running Hatchet locally and in production
Developers start a local instance with hatchet server start or use embedded mode in tests and CI. Production deployments use Docker Compose or the Helm chart with PostgreSQL and optional RabbitMQ, FIPS images where required, or connect workers to Hatchet Cloud; the cloud-vs-OSS page states that workers move between the two by pointing them at a new endpoint.
Install
curl -fsSL https://install.hatchet.run/install.sh | bashReviews of Hatchet
Be the first to share your experience with Hatchet.
Write a review
Loading review form…
Alternatives to Hatchet
TemporalTemporal runs application logic as durable Workflows and Activities written with SDKs in Go, Java, Python, TypeScript, .NET, PHP, Ruby or Rust. The MIT-licensed server is self-hosted or used as the usage-priced Temporal Cloud.
DagsterDagster is an asset-based data orchestrator with lineage and quality signals per asset, and is now part of Prefect.
AstronomerAstronomer builds Astro, a fully managed Apache Airflow platform with Private Cloud and an agent called Otto, priced by usage from $0.35 per hour.