Hatchet

Connect an agent via an official MCP server G

Agent access

Drive the product through a documented public API G

Agent access

Delegate tasks to a built-in AI assistant inside the product G

Agentic features

Plug MCP servers into this product so it can use their tools G

Agent access

Point an agent at llms.txt or agent-oriented docs G

Agent access

Build against official SDKs G

Agent access

Run the product headlessly / in CI for automation G

Agent access

Set up automations that run autonomously in the background G

Agentic features

Use an official CLI G

Agent access

Subscribe to events via webhooks G

Agent access

Download a machine-readable API spec (OpenAPI or equivalent) G

Api quality

Explore an interactive API reference with runnable examples G

Api quality

Operate the product with natural-language commands G

Agentic features

Rely on versioned APIs with a documented deprecation policy G

Api quality

Get AI-generated insights and suggestions from my data inside the product G

Agentic features

Issue scoped/least-privilege API credentials for an agent G

Agent access

Test against a sandbox environment without touching production data G

Api quality

Self-host the core product G

Define rules that trigger actions automatically on events G

I run LLM agent loops as durable workflows — model and tool calls as checkpointed, retried steps that survive crashes mid-run C

Agent loops

A workflow interrupted by a process crash, deploy, or infrastructure failure resumes from its last completed step with state intact C

Recovery

Every step retries automatically with configurable backoff, timeouts, and failure policies — no try/catch scaffolding C

Retries

I write workflows as ordinary code in my language — steps with automatic checkpointing — not YAML or a proprietary DSL C

Authoring

Every run has a step-by-step timeline — inputs, outputs, retries, and errors per step — in a dashboard my team can search and filter C

Run visibility

Export all of my data in open formats and leave G

A workflow pauses for human approval or input for hours or days and resumes the moment the response arrives C

Approvals

I deploy new workflow code while in-flight runs finish on the version they started with — versioning without breaking determinism C

Versioning

Prevent my data from being used to train AI models G

I cap concurrency and set rate limits per workflow, per key, or per tenant so one hot customer can't starve the rest C

Flow control

Schedule recurring jobs or workflows G

Events from my app, webhooks, or queues trigger workflows declaratively, and one event can fan out to many functions C

Events

First-party integrations wrap my AI stack — AI SDKs, agent frameworks, model providers — so agent steps get durability without glue code C

Ai integrations

I author workflows in the language my team already uses — TypeScript, Python, Go, or more — with real feature parity across SDKs C

Language coverage

Throughput scales by adding workers — the platform load-balances tasks across the fleet and tolerates worker loss C

Scaling

Do everything through the API that I can do in the UI G

I schedule workflows on cron expressions with overlap policies, pause/resume, and visibility into upcoming runs C

Schedules

Perform bulk operations across many items at once G

A workflow can sleep or wait for days to months without holding a server, connection, or billable compute C

Long running

I run workers in my own infrastructure while the vendor manages the orchestration control plane — code and data stay inside my network C

Deployment model

Choose where my data is stored (region/residency) G

Control data retention and deletion G

I send signals, events, or messages into a specific running workflow from outside — an API call, webhook, or another workflow C

Signals

One command runs the whole engine locally, and testing utilities let me unit-test workflows with time skipping and mocked steps C

Local dev

Read the product's source under an open license G

I compose workflows from parallel steps, fan-out/fan-in over dynamic batches, and child workflows without hand-rolling coordination C

Composition

I replay or rerun a failed workflow from its recorded history — optionally from a specific step — to debug and recover C

Replay

I stream live progress — step updates or model tokens — from a running workflow into my frontend as it executes C

Streaming

Idempotency keys and exactly-once step semantics stop duplicate triggers from double-charging or double-sending C

Exactly once

Opt out of telemetry and usage tracking G

Failure rates, latencies, and queue depths export to my observability stack, and alerts fire when workflows misbehave C

Metrics

I assign priorities to runs and get fair scheduling across tenants instead of a single FIFO queue C

Prioritization

I debounce, batch, or delay triggers so noisy event streams collapse into the runs I actually want C

Flow shaping

Version, review, and roll back my automations G