Hatchet vs Atlassian Remote MCP Server

Hatchet executes complex multi-step workflows defined as directed acyclic graphs (DAGs) stored in the v1_dag table, with built-in hierarchical concurrency management that enforces resource limits at workflow, step, and action levels. The system uses a state machine approach for task lifecycle management (v1_task table) with automatic persistence, enabling workflows to survive service restarts and coordinate dependencies across distributed workers via gRPC streaming.

Unique: Implements hierarchical concurrency control (workflow-level, step-level, action-level semaphores) with fairness scheduling specifically optimized for LLM rate limiting, rather than generic task queue concurrency. Uses PostgreSQL partitioning for v1_task table to scale task state management without sharding application logic.

vs alternatives: More sophisticated than Celery/RQ for concurrency fairness; lighter than Airflow/Prefect by eliminating scheduler overhead through event-driven task assignment via gRPC streaming.

Hatchet triggers workflow runs in response to external events using a CEL (Common Expression Language) expression matcher stored in v1_filter and v1_match tables. When an event is published to the system, the dispatcher evaluates CEL expressions against event payloads to determine which workflows should be triggered, enabling complex conditional logic without hardcoding trigger rules. This architecture decouples event producers from workflow definitions.

Unique: Uses CEL (Common Expression Language) for event matching instead of regex or hardcoded rules, enabling Turing-complete conditional logic while remaining sandboxed and safe. Stores filter definitions in v1_filter table, allowing triggers to be updated without redeploying workers.

vs alternatives: More expressive than webhook path-based routing; simpler than building custom event processors with Kafka Streams or Flink.

Hatchet scales horizontally by running multiple dispatcher instances, each managing a subset of worker connections based on worker affinity or hash-based sharding. Workers register with a specific dispatcher instance, and the system routes task assignments to the appropriate dispatcher based on worker availability. The architecture supports adding/removing dispatcher instances without downtime, with workers automatically reconnecting to available dispatchers on failure.

Unique: Implements dispatcher sharding with worker affinity-based routing, allowing horizontal scaling of task assignment throughput without central bottleneck. Workers register with specific dispatcher instances and automatically reconnect on failure.

vs alternatives: More scalable than single-dispatcher architecture; simpler than Kafka-based task distribution but requires careful sharding configuration.

Hatchet includes built-in observability through structured logging (api/v1/server/middleware/telemetry/telemetry.go) and metrics export to OpenTelemetry-compatible backends. The system logs task execution events, worker lifecycle events, and API requests with structured fields (tenant_id, workflow_id, task_id) for easy filtering and correlation. Metrics include task latency, success rates, worker utilization, and dispatcher throughput, exported via OpenTelemetry SDK.

Unique: Implements structured logging with correlation IDs (tenant_id, workflow_id, task_id) and OpenTelemetry metrics export, enabling end-to-end tracing across dispatcher, workers, and API. Logs are JSON-formatted for easy parsing by log aggregation platforms.

vs alternatives: More comprehensive than basic logging; simpler than custom instrumentation but requires external observability platform for full value.

Hatchet supports PostgreSQL PGMQ as a built-in message queue alternative to RabbitMQ, eliminating the need for a separate message broker in simpler deployments. PGMQ uses PostgreSQL tables for queue storage, with the same API as RabbitMQ but without external dependencies. This is suitable for deployments where PostgreSQL is already required and operational complexity should be minimized.

Unique: Provides PostgreSQL PGMQ as a built-in message queue alternative to RabbitMQ, eliminating external broker dependencies for simpler deployments. Uses PostgreSQL tables for queue storage with the same API as RabbitMQ.

vs alternatives: Simpler than RabbitMQ for small deployments; lower throughput but fewer operational dependencies.

Hatchet stores workflow definitions with versioning, allowing multiple versions of a workflow to coexist. Each workflow run is bound to a specific workflow version, ensuring that historical runs can be replayed or analyzed against the exact workflow definition that executed them. The system maintains immutable run history in the v1_workflow_run table, preventing accidental modification of historical data.

Unique: Implements workflow versioning with immutable run history, binding each run to a specific workflow version. Enables safe workflow updates without affecting in-flight runs and maintains audit trail of all workflow changes.

vs alternatives: More robust than unversioned workflows; simpler than full workflow state machine versioning in Temporal.

Hatchet's dispatcher service (dispatcher_v1.go) maintains persistent gRPC streaming connections to workers, pushing task assignments in real-time rather than workers polling a queue. The dispatcher monitors worker heartbeats and automatically reassigns tasks from dead workers, implementing a pull-based model where workers declare availability and the dispatcher matches them to queued tasks. This architecture reduces latency and enables fair scheduling across heterogeneous worker pools.

Unique: Uses persistent gRPC streaming for push-based task assignment instead of pull-based polling, with automatic heartbeat-based failure detection and task reassignment. Dispatcher maintains worker registration state and matches tasks to workers based on declared availability, enabling fair scheduling without explicit queue management.

vs alternatives: Lower latency than Redis/RabbitMQ polling-based queues; more sophisticated failure detection than simple timeout-based reassignment.

Hatchet persists task state in the v1_task table with built-in retry logic that automatically re-executes failed tasks using exponential backoff (configurable base and max multiplier). Each task has a timeout enforced at the dispatcher level; if a task exceeds its timeout, the dispatcher marks it as failed and triggers the retry mechanism. The system tracks retry count and can enforce a maximum retry limit, with all retry history persisted for debugging.

Unique: Implements dispatcher-enforced timeouts combined with automatic exponential backoff retry, with full retry history persisted in v1_task table. Decouples retry logic from worker implementation, ensuring consistent behavior across heterogeneous worker pools.

vs alternatives: More sophisticated than simple retry loops in application code; less flexible than Temporal's activity retry policies but simpler to operate.

This capability allows users to create and update Jira work items through API calls. It utilizes structured input data to ensure that all necessary fields are populated according to Jira's requirements, providing confirmation upon successful creation or update.

Unique: Integrates directly with Jira's API using OAuth 2.1, ensuring secure and authenticated operations for work item management.

vs alternatives: More secure and compliant than third-party tools that may not adhere to Atlassian's API security standards.

This capability enables users to draft new content in Confluence through API interactions. It accepts structured input that defines the content type and structure, allowing for seamless integration of new pages or updates to existing content.

Unique: Utilizes a secure API connection to Confluence, enabling real-time content updates while respecting user permissions and content guidelines.

vs alternatives: Provides a more streamlined and secure approach compared to manual content updates or less integrated third-party solutions.

Rovo Search allows users to perform structured searches on Jira and Confluence data. It processes input queries to return relevant structured data, ensuring that users can access the information they need efficiently without exposing raw data.

Unique: Designed to efficiently query Atlassian's data structures, providing a tailored search experience that respects user permissions and data integrity.

vs alternatives: Offers a more integrated search experience compared to generic search APIs, ensuring context-aware results based on user permissions.

Rovo Fetch enables users to fetch specific data from Jira and Confluence, allowing for targeted retrieval of information based on user-defined parameters. This capability ensures that users can access the exact data they need without unnecessary overhead.

Unique: Optimized for fetching data with minimal latency, ensuring that users can retrieve necessary information quickly and efficiently.

vs alternatives: More efficient than traditional API calls that may require multiple requests to gather the same data.

Atlassian's Remote MCP Server is a hosted solution that connects agents to Jira and Confluence Cloud, allowing for seamless automation of workflows without local installation. It leverages OAuth 2.1 for secure access, enabling teams to manage work items and documentation efficiently.

Unique: This MCP server is fully hosted by Atlassian, providing a secure and compliant environment for enterprise use without the need for local infrastructure.

vs alternatives: Offers a more integrated and secure solution compared to self-hosted MCP servers, with direct support from Atlassian.