Hatchet
Hatchet · Coding · Productivity
Hatchet is an open source orchestration engine for background tasks, AI agents, and durable workflows. Workers run in your own cloud, and every run is stored so you can retry or replay it.
About Hatchet
What Is Hatchet
Hatchet is a task orchestration platform for teams that already know how to write a function but don't want to babysit the queue around it. You define tasks in code, compose them into workflows, and Hatchet handles scheduling, retries, concurrency limits, and run history.
The design choice that matters most is where your code lives. As a workflow orchestration engine, Hatchet keeps scheduling on its side and execution on yours. The engine is a managed service, but workers run on your own infrastructure, whether that's Kubernetes, ECS, Railway, or a laptop during development. Customer data stays in your cloud while scheduling metadata lives in Hatchet's Postgres-backed engine. That split is why the team markets it as a self-hosted job queue you can also rent by the run.
Hatchet targets the mess that shows up once a product has more than a couple of background jobs. A homegrown cron script, a Celery queue with hand-rolled retries, and a separate pipeline tool each solve one slice. Hatchet replaces all three with one model: every task is a function, every function keeps its state, and every failure is visible with a stack trace.
The limits are honest ones. Hatchet is infrastructure for people who write code. There's no drag and drop workflow builder, no no-code canvas, and no way to define a production workflow through the dashboard alone. If your team doesn't ship Python, TypeScript, Go, or Ruby, this isn't the tool.
Getting Started
- Create an account at hatchet.run and grab an API token from the dashboard. No credit card is needed for the free tier.
- Install a client SDK, then define your first task as a normal function with a typed input and output.
- Register the task on a worker and start that worker process inside your own environment so it connects back to Hatchet.
- Trigger the task from your API, a cron expression, or an incoming event, then open the run in the dashboard to watch each step.
- Add retry policy and concurrency limits once the happy path works, then promote the workflow to stricter environments using separate tenants.
Product Information
A quick look at Hatchet's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- Backend engineers replacing a homegrown background task queue
- AI product teams running multi-step agents
- Data and platform teams with tenant fairness problems
- Startups that expect to self-host later
Tasks
- Background job processing
- AI agent orchestration
- Scheduled and event-driven workflows
- Large ingestion pipelines
Scenarios
- Migrating off a fragile cron setup that nobody wants to touch on a Friday afternoon.
- Running a research agent that takes 30 minutes and needs to survive a deploy in the middle.
- Onboarding a new service that needs per-user fairness from day one instead of a rate limiter written under deadline pressure.
Key features
Durable Execution Backed by Postgres
Every task and every state transition is written to Postgres, so a crashed worker doesn't lose work in flight. Durable execution means a run can pause, wait, and resume later, including after a deployment or an outage. You can replay a failed run from the dashboard instead of guessing what the input was.
Concurrency, Rate Limits, and Fairness
Concurrency limits can be keyed on input fields, so one noisy customer can't consume every worker slot. Global and dynamic rate limits sit next to priority and fairness controls for queues that serve multiple tenants. This is the part teams usually build by hand and regret.
Workflow Composition with Child Tasks
Tasks compose into DAGs, and a task can spawn children at runtime, which suits fan-out work like processing a thousand documents in parallel. Outputs pass to dependent steps automatically, and each child keeps its own retry and status. Long-running workflows stay readable because each step is a plain function.
Triggers for Events, Cron, and Webhooks
Workflows start from your API, a cron expression, a scheduled timestamp, or an inbound event. Built-in webhook ingestors mean you don't need a separate service just to catch a Stripe or GitHub callback. Events can be replayed too, which is handy when a downstream system was down when the event arrived.
Observability with OpenTelemetry
Hatchet runs an OpenTelemetry collector, so each run produces traces and spans you can forward to your existing stack. Application logs are searchable in the dashboard with full-text search and filters. Failure alerts go out before a customer notices the missing email.
SDKs and Self-Hosting Without Limits
Official SDKs cover Python, TypeScript, Go, and Ruby, and the same task definition works in cloud and self-hosted deployments. Self-hosting runs the engine, dashboard, and Postgres together, and the MIT license puts no cap on runs. Teams that start on the free cloud tier can move the engine in-house later without rewriting tasks.
Pros and cons
Pros
- The task model is small: a function, a typed input, a typed output. Most engineers are productive in an afternoon.
- Run history is genuinely useful, with step-level status, logs, and replay instead of a log file you grep by hand.
- Concurrency keys and rate limits are first-class features, which removes a whole layer of custom throttling code.
- Self-hosting is a real option under MIT, so the open source workflow engine isn't a crippled demo build.
Cons
- You still deploy and scale the workers yourself, so the operational burden moves rather than disappears.
- There's no visual workflow builder, which rules it out for teams that want non-engineers editing automations.
- Very high-throughput shops may find per-run pricing harder to forecast than a flat platform fee.
- The dashboard focuses on runs and queues, not on business-level analytics, so product reporting needs another tool.
Frequently asked questions
Yes, up to a point. The cloud tier includes one million task runs and one million events per month with no credit card, and self-hosting the MIT licensed engine costs nothing beyond your own infrastructure.
Related content
Explore related tools, skills, and articles for Hatchet.
Hatchet Alternatives
Base Code
Base44 (Wix) · Coding · ProductivityBase Code is a shared cloud development environment from Base44. Teammates describe changes to an existing GitHub codebase in chat, preview them live and send them back as pull requests.
Google EmbeddingGemma 2
Google DeepMind · Writing · Image · CodingGoogle EmbeddingGemma 2 is a 740M-parameter open model that turns text, code, images, audio, and video frames into vectors in one 768-dimension space, running on phones and laptops.
GitGlow
GitGlow · Coding · ProductivityGitGlow is a local-first desktop Git client that lets independent developers review their own code and their AI agents' changes in one place before shipping.