Hatchet

Hatchet is a high-performance computing service engineered for modern development challenges, specializing in the management of AI agents, background tasks, and complex data pipelines. Built upon an open-source, fault-tolerant queue, Hatchet guarantees reliable task delivery and execution, even under heavy load or in the event of system failures. It provides a robust solution for developers looking to scale their applications without compromising on speed or reliability, boasting an average scheduling latency of just 20ms.

The platform is designed to seamlessly integrate into your existing technology stack, offering a durable task queue that ingests tasks and dispatches them to workers at a manageable rate. This prevents system overloads, smooths out traffic spikes, and ensures that every user request is processed. Whether you're building a simple background job processor or a sophisticated, multi-step AI workflow, Hatchet provides the tools to break down complex logic into smaller, manageable, and reusable tasks.

How to use Hatchet

Integrating Hatchet into your project is a straightforward process designed for developer efficiency. The workflow typically involves four key steps:

1. Define Your Task: Using one of the provided SDKs (Python, TypeScript, or Go), you start by defining the input structure for your task, often using a class or model.
2. Create the Task Function: You then write the core logic of your task as a function and decorate it with `@hatchet.task()` to make it recognizable to the Hatchet system. This function processes the input and returns a result.
3. Register the Task on a Worker: In your worker process, you initialize a Hatchet worker, providing it with a name and a list of the task functions you want it to handle. Starting the worker connects it to the Hatchet queue, making it ready to receive and execute jobs.
4. Invoke the Task: From your main application, you can trigger the task by calling its `.run()` method and passing the required input. Tasks can be triggered by events, scheduled for a future time, or run directly via the API.

Core Features of Hatchet

• Durable Task Queuing: Guarantees that tasks are not lost, even if your application crashes. It tracks task progress and ensures completion or alerts you to failures.
• Advanced Workflow Orchestration: Build complex, multi-step workflows with sophisticated flow control, scheduling, and routing capabilities.
• High-Throughput & Low-Latency: Engineered to handle large volumes of tasks with minimal delay, ensuring your applications remain responsive.
• Built-in Observability: Comes with real-time dashboards, metrics, structured logging, and integrated alerting (Slack and email) to monitor your systems effectively.
• Multi-language SDKs: Native support for Python, TypeScript, and Go allows for seamless integration into a wide variety of tech stacks.
• Flexible Deployment: Choose between the fully managed Hatchet Cloud or self-host the MIT-licensed open-source version. Workers can be run on your own infrastructure for maximum control.
• Enterprise-Ready: Designed for enterprise needs with a highly scalable architecture, SOC 2 Type II compliance (under audit), and expert support options.

Use Cases for Hatchet

Hatchet is versatile and particularly useful for:

• Asynchronous Background Jobs: Offloading long-running tasks like sending emails, processing images/videos, or generating reports without blocking the main application thread.
• AI & Machine Learning Pipelines: Orchestrating complex AI workflows, including data ingestion, preprocessing, model training, and inference, ensuring each step runs reliably.
• Data Processing Pipelines: Building scalable and resilient pipelines for ETL (Extract, Transform, Load) jobs and real-time data analysis.
• Event-Driven Systems: Creating responsive applications that trigger workflows based on user actions, system events, or external webhooks.
• Handling Traffic Spikes: Using the queue to absorb and process large, sudden bursts of requests, ensuring system stability and a smooth user experience.

Advantages of Hatchet

Hatchet offers significant advantages over traditional task management systems:

• Reliability: Its fault-tolerant design ensures that critical tasks are never dropped.
• Scalability: The architecture is built to scale from small projects to large, high-growth company needs.
• No Vendor Lock-in: As a fully open-source tool, you have the freedom to self-host and customize it. You can run workers anywhere, connecting them to Hatchet Cloud or your own instance.
• Developer Experience: The intuitive SDKs and comprehensive observability tools simplify development, debugging, and maintenance.
• Cost-Effective: With a generous free tier and transparent pricing, it's accessible to projects of all sizes. The ability to self-host provides further cost control.

Pricing and Plans

Hatchet offers flexible pricing for both its managed cloud and self-hosted options.

• Managed Cloud Packages:
  • Free: $0/mo. Ideal for testing and small projects. Includes 2k task runs/day, 1-day data retention, and community support.
  • Starter: $180/mo. For systems starting to scale. Includes 20k task runs/day, 1-week data retention, and increased limits.
  • Growth: $425/mo. For larger services with complex scaling needs. Includes 100k task runs/day, 2-week data retention, and private Slack support.
  • Enterprise: Custom pricing. For complex systems with unique requirements, offering custom limits, SLAs, and dedicated support.
• Self-Hosted Support Packages:
  • Essentials: $500/mo. Provides support with a 2-business-day SLA for self-hosted instances.
  • Enterprise: $2000/mo. Offers premium support with a 1-business-day SLA, shared Slack channel, and advanced infrastructure guidance.